home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
CD ROM Paradise Collection 4
/
CD ROM Paradise Collection 4 1995 Nov.iso
/
dskutil
/
2m30src.zip
/
2MGUI.ASM
< prev
next >
Wrap
Assembly Source File
|
1995-03-06
|
269KB
|
6,550 lines
;┌───────────────────────────────────────────────────────────────────┐
;│ │
;│ █████ █ █ █████ █ █ █████ │
;│ █ ██ ██ █ █ █ █ │
;│ █████ █ █ █ █ ███ █ █ █ │
;│ █ █ █ █ █ █ █ █ │
;│ █████ █ █ █████ █████ █████ V 1.0 │
;│ │
;│ │
;│ CODIGO PARA CREAR Y CONTROLAR DISQUETES │
;│ APROVECHANDO LA CAPACIDAD ANTES DE FORMATEAR │
;│ EN SISTEMAS PC, XT, AT - ISA/EISA/VLB/PCI (No MCA) │
;│ CON CONTROLADORAS Y UNIDADES DE ALTA DENSIDAD │
;│ │
;│ (C) 1994-1995 Ciriaco García de Celis. │
;│ Email: ciri@gui.uva.es │
;│ FidoNET 2:341/21.8 │
;│ Grupo Universitario de Informática │
;│ Facultad de Ciencias - Valladolid (España) │
;│ │
;│ Ensamblar con TASM 2mgui /m5 y enlazar con TLINK 2mgui │
;│ Se necesita el fichero 2MUTIL.INC incluído en 2M 3.0 │
;│ │
;└───────────────────────────────────────────────────────────────────┘
; ------------ Constantes fundamentales y valores por defecto.
M_DMA EQU ON ; modo DMA por defecto
FRONT EQU 28 ; pista de división del disco 360DH
GAPDEF EQU 20 ; GAP anti-FIFO por defecto
MODOWR EQU ON ; por defecto, caché de escritura
W_CACHE_TM EQU 9 ; escritura retardada: 9/18 segundos
PRE_GAP3 EQU 20 ; GAP3 para preformateo
MPISTA EQU 30000 ; mayor pista absoluta posible
PISTAS EQU 82 ; nº pistas por defecto
SECTDEF EQU 128 ; tamaño de sector lógico por defecto
CLUSDEF EQU 1024 ; tamaño de clúster por defecto
MINROOT EQU 128 ; entradas raíz mínimo por defecto
SLID_X EQU 55 ; sliding X por defecto (en grados)
SLID_Y EQU 90 ; sliding Y por defecto (en grados)
t_525_dd EQU 6098 ; tamaños recomendados (t_)
m_525_dd EQU 6250 ; y límites teóricos por pista (m_)
t_525_hd EQU 10239
m_525_hd EQU 10416
t_35_dd EQU 7343
m_35_dd EQU 7500
t_35_hd EQU 12313
m_35_hd EQU 12500
t_35_ed EQU 24626
m_35_ed EQU 25000
; ------------ Macros de propósito general.
XPUSH MACRO regmem ; apilar lista de registros
IRP rm, <regmem>
PUSH rm
ENDM
ENDM
XPOP MACRO regmem ; desapilar lista de registros
IRP rm, <regmem>
POP rm
ENDM
ENDM
XPUSHA MACRO
XPUSH <AX, BX, CX, DX, SI, DI, BP>
ENDM
XPOPA MACRO
XPOP <BP, DI, SI, DX, CX, BX, AX>
ENDM
DDS MACRO
PUSH AX
MOV AX,40h
MOV DS,AX
POP AX
ENDM
DELAY MACRO ; estados de espera
JMP SHORT $+2 ; para AT obsoleto
JMP SHORT $+2
ENDM
PMICRO MACRO ; retardo de aprox. 15,09 µs
LOCAL pmicro_iter ; (exactamente 18/1193180 sg.)
pmicro_iter: DELAY
IN AL,61h ; Esta macro puede ejecutarse
AND AL,10h ; repetitivamente (se apoya en
CMP AL,AH ; AX) para hacer retardos a
JE pmicro_iter ; través de la temporización
MOV AH,AL ; del refresco de la memoria
ENDM ; dinámica de los AT.
; ------------ Estructuras de datos.
cab_PETICION STRUC ; parte inicial común a todos
tamano DB ? ; los comandos de la cabecera
unidad_disco DB ? ; de petición
orden_dsp DB ?
estado DW ?
dos_info DB 8 DUP (?)
cab_PETICION ENDS
cab_INIT_BBPB STRUC ; para comandos INIT/BUILD_BPB
DB (TYPE cab_PETICION) DUP (?)
num_disc_init DB ? ; número de unidades definidas
fin_resid_desp DW ? ; área que quedará residente
fin_resid_segm DW ?
bpb_cmd EQU THIS DWORD
bpb_cmd_desp DW ? ; línea de órdenes del CONFIG
bpb_cmd_segm DW ? ; y puntero al BPB
nuevo_disco DB ? ; (DOS 3+) (0-A:, 1-B:,...)
cab_INIT_BBPB ENDS
cab_MEDIACHECK STRUC ; estructura para MEDIA CHECK
DB (TYPE cab_PETICION) DUP (?)
media_descrip DB ? ; descriptor de medio
cambio DB ? ; 1: no cambiado, 0FFh:sí, 0:?
cab_MEDIACHECK ENDS
cab_READ_WRITE STRUC
DB (TYPE cab_PETICION) DUP (?)
DB ? ; descriptor de medio
transfer_desp DW ? ; dirección de transferencia
transfer_segm DW ?
transfer_sect DW ? ; nº de sectores a transferir
transfer_sini DW ? ; primer sector a transferir
cab_READ_WRITE ENDS
cab_GEN_IOCTL STRUC
DB (TYPE cab_PETICION) DUP (?)
categoria_cod DB ? ; código de categoría
func_cod DB ? ; código de función
copia_ds DW ?
offset_cab DW ?
ioctl_info DD ? ; puntero a información
cab_GEN_IOCTL ENDS
; --- Estructura con información local a la unidad.
; Contiene información IOCTL, el BPB y otras.
InfoBoot STRUC ; subestructura auxiliar
vformat DW 0100h ; versión 1.0
fformat DW 0 ; sin flags especiales en esta versión
vunidad2 DB ? ; densidad segunda parte del disco
mfrontera DB ? ; frontera divisora
tpista1 DW ? ; tamaño físico pistas 0..FRONTERA-1
tpista2 DW ? ; tamaño físico pistas FRONTERA..81
idboot DW 0AA55h ; ID de sector válido
InfoBoot ENDS
info_unidad STRUC
DB ? ; "sectores iguales" o no
DB ? ; tipo (1-1.2, 7-1.44, 9-2.88)
DW ? ; detección de cambio
ioctl_pistas DW ? ; nº pistas
ioctl_id DB '2'+'M' ; tipo de soporte
bytes_sector DW ? ; BPB: bytes por sector
sect_cluster DB ? ; BPB: sectores por cluster
sect_reserv DW ? ; BPB: sectores reservados
num_fats DB ? ; BPB: número de FATs
entradas_raiz DW ? ; BPB: entradas en el raíz
num_sect DW ? ; BPB: nº total de sectores
media_byte DB ? ; BPB: descriptor de medio
sectores_fat DW ? ; BPB: sectores por FAT
sectores_pista DW ? ; BPB: sectores por pista
num_cabezas DW ? ; BPB: cabezas
sects_ocultos DD ? ; BPB: sectores ocultos
DD 0 ; BPB: sectores (32bit)
DB 11 DUP (0) ; BPB: restantes campos
unidad DB ? ; unidad física
tipo_drv DB 0 ; tipo de la disquetera (0 = no hay)
modobios DB ON ; a ON si el disquete no es 2MGUI
controldrv DB OFF ; a ON si el disco lo controla 2MGUI
cambiodisco DB ON ; a ON por defecto para simular cambio
cilindro DB ? ; cilindro del disco a acceder
cabezal DB ? ; cabezal a emplear
vunidad1 DB ? ; # velocidad primer medio disco
infb InfoBoot <> ; información del BOOT
tsector DB ? ; # LOG2 (tamaño buffer) redondeado
prot_esc DB ? ; ON = disco protegido contra escritura
numserie DD 12345678h ; número de serie del disco
evol DB "NO NAME " ; etiqueta de volúmen (BOOT)
fsystem DB "FAT12 " ; sistema de ficheros
info_unidad ENDS
; ------------ Códigos de modos y órdenes del DMA, FDC,...
BIOS_READ EQU 2
BIOS_WRITE EQU 3
F_READ EQU 46h ; modo DMA para lectura
F_WRITE EQU 4Ah ; modo DMA para escritura
F_VERIFY EQU 42h ; modo DMA para verificación
F_FORMAT EQU 01001101b ; orden de formateo del FDC
TICSTIMEOUT EQU 9322 ; constante para 2 segundos
FD_STATUS EQU 3F4h ; registro de estado
FD_DOR EQU 3F2h ; registro de salida digital
FD_DIR EQU 3F7h ; registro de entrada digital
FD_DCR EQU 3F7h ; registro de control disco
; ************ Inicio del área residente.
_PRINCIPAL SEGMENT
ASSUME CS:_PRINCIPAL, DS:_PRINCIPAL
ORG 0
ini_residente EQU $
DD -1 ; encadenamiento con otros drivers
tipo_drive DW 2840h ; palabra de atributo:
; bit 15 a 0: dispositivo de bloques
; bit 14 a 0: sin control IOCTL
; bit 13 a 1: SIN formato IBM
; bit 11 a 1: Open/Close/Remove
; bit 6 a 1: Generic Ioctl
DW estrategia ; rutina de estrategia
DW interrupcion ; rutina de interrupción
num_discos DB 255 ; número de unidades (255 antes
; de que INIT lo inicialice)
; ***************************************************
; * *
; * D A T O S D E L C O N T R O L A D O R *
; * *
; ***************************************************
; ------------ Identificación estandarizada del programa.
program_id LABEL BYTE
segmento_real DW 0 ; segmento real donde será cargado
offset_real DW 0 ; offset real " " "
longitud_total DW 0 ; zona de memoria ocupada (párrafos)
info_extra DB 03h ; bits 0, 1 y 2-> 000: normal, con PSP
; 001: bloque UMB XMS
; 010: *.SYS
; 011: *.SYS formato EXE
; bit 7 a 1: «extension_id» definida
multiplex_id DB 0 ; número Multiplex de este TSR
vectores_id DW tabla_vectores
extension_id DW 0
DB "*##*"
autor_nom_ver DB "CiriSOFT:2MGUI:1.0",0
DB 3 ; número de vectores de interrupción usados
tabla_vectores EQU $
DB 8h ; INT 8h
ant_int08 LABEL DWORD ; dirección original
ant_int08_off DW 0
ant_int08_seg DW 0
DB 13h ; INT 13h
ant_int13 LABEL DWORD ; dirección original
ant_int13_off DW 0
ant_int13_seg DW 0
DB 2Fh ; INT 2Fh
ant_int2F LABEL DWORD ; dirección original
ant_int2F_off DW 0
ant_int2F_seg DW 0
; ------------ Datos de trabajo.
pcab_peticion LABEL DWORD ; puntero a la cabecera de petición
pcab_pet_desp DW 0
pcab_pet_segm DW 0
p_rutinas LABEL WORD ; tabla de rutinas del controlador
DW init
DW media_check
DW build_bpb
DW nofunc
DW read
DW read_nowait
DW input_status
DW input_flush
DW write
DW write_verify
DW output_status
DW output_flush
DW ioctl_output
DW open ; DOS 3.0+
DW close ; DOS 3.0+
DW remove ; DOS 3.0+
DW nofunc
DW nofunc
DW nofunc
DW generic_ioctl ; DOS 3.2+
drv_pvars LABEL WORD ; punteros a variables y BPB
DW info_E
DW info_F
bpb_ptrs LABEL WORD ; tabla de punteros BPB
DW info_E.bytes_sector
DW info_F.bytes_sector
info_E info_unidad <> ; 2 BPB's para las 2 unidades
info_F info_unidad <> ; posibles ya inicializados y
; sus variables particulares.
info_BUF info_unidad <> ; para la pista en el buffer
pet_fantasma cab_READ_WRITE <> ; cabecera de petición de
; solicitud fantasma
; ----- Variables de control globales.
unidad_base DB ? ; primera letra de unidad definida
tbase DW ? ; constante para retardos (XT)
pcxt DB OFF ; a ON si no es AT
drdos6 DB OFF ; a ON si es DR-DOS 6.0 ó Novell DOS 7.0
tbuffer DW ? ; tamaño del buffer interno en bytes
sbuffer DW ? ; puntero al segmento del buffer
sbuf512 DW ? ; copia de seguridad del mismo
ems_handle DW 0 ; handle EMS (si usado)
marco_ems DW ? ; marco de página EMS (si usado)
ems4 DB OFF ; a ON en EMS 4.0+
SYSBYTES EQU 2 ; en cada pista, NOT(checksum) (2 bytes)
gaprw DW GAPDEF ; GAP R/W simulado
cachewr DB MODOWR ; modo para la caché de escritura
modoDMA DB M_DMA ; modo DMA activo por defecto
sentidoIO DB ? ; F_WRITE ó F_READ según operación NO-DMA
bytesIO DW ? ; bytes para operación NO-DMA
sector_ini DB ? ; número de sector inicial en los accesos
sector_fin DB ? ; número de sector final en los accesos
off_ini DW ? ; # offset inicial en la pista
off_fin DW ? ; # offset final en la pista + 1
bytes DW ? ; # bytes a transferir
wrpend DB OFF ; a ON si pista en buffer aún no escrita
expiraw DB ? ; contador de tics escritura retardada
orden DB ? ; operación READ/WRITE
verificar DB OFF ; a ON si WRITE VERIFY
status DB ? ; resultado de los accesos a disco
fdc_result DB 7 DUP (?) ; bytes de resultados del FDC
; --- Interpretación BIOS de los bits de ST1
lista_errs DB 4 ; 'sector not found'
DB 0
DB 10h ; 'bad CRC'
DB 8 ; 'DMA overrun'
DB 0
DB 4 ; 'sector not found'
DB 3 ; 'write-protect error'
DB 2 ; 'address mark not found'
DB 20h ; en otro caso: 'bad NEC'
; *****************************************************
; * *
; * C O D I G O D E L C O N T R O L A D O R *
; * *
; *****************************************************
; ------------ Rutina de gestión de INT 2Fh.
; También se impide que SMARTDRIVE 4.0+ cachee por
; defecto las nuevas unidades (se cuelga al acceder si
; los sectores no son de 512 bytes).
ges_int2F PROC FAR
STI
PUSH CX ; *
CMP AX,4A10h
JNE i2f_tsr ; no llama smartdrive
CMP BX,6
JNE i2f_tsr ; no llama smartdrive
SUB CL,CS:unidad_base
DEC CL
JZ no_gracias ; llama smartdrive
CMP CS:info_F.unidad,0
JE i2f_tsr ; no llama para nuestra unidad
DEC CL
JNZ i2f_tsr ; no llama para nuestra unidad
no_gracias: POP CX ; *1
MOV AX,6 ; nos llama: "No, gracias"
RETF 2
i2f_tsr: POP CX ; *2
CMP AH,CS:multiplex_id
JE preguntan
JMP CS:ant_int2F ; saltar al gestor de INT 2Fh
preguntan: CMP DI,1992h
JNE ret_no_info ; no llama alguien del convenio
MOV AX,ES
CMP AX,1492h
JNE ret_no_info ; no llama alguien del convenio
PUSH CS
POP ES ; sí llama: darle información
LEA DI,autor_nom_ver
ret_no_info: MOV AX,0FFFFh ; "entrada multiplex en uso"
IRET
ges_int2F ENDP
; ------------ Rutina de gestión de INT 8. Se utiliza para grabar
; en disco el buffer con la pista pendiente de ser
; grabada (caché de escritura retardada) si pasa
; demasiado tiempo tras el último acceso.
ges_int08 PROC FAR
CLI ; por si llamada con CALL/JMP
CMP CS:wrpend,OFF
JE bye08
DEC CS:expiraw
JNZ bye08
XPUSHA ; *
XPUSH <DS, ES> ; **
XPUSH <CS, CS>
XPOP <DS, ES>
MOV AL,20h
OUT 20h,AL ; para que funcione IRQ6 ;-)
CALL abs_flush
XPOP <ES, DS> ; **
XPOPA ; *
bye08: JMP CS:ant_int08
ges_int08 ENDP
; ------------ Rutina de gestión de INT 13h. Se utiliza para simular
; cambios de disco tanto en las nuevas unidades como en
; las normales, cuando el usuario conmuta entre ambas,
; ya que el primer acceso desde una de ellas baja la
; línea de cambio y ésta es la única manera de asegurar
; que la información del disco se corresponde con éste
; y no con otro antiguo ya sustituído.
ges_int13 PROC FAR
STI
CMP DL,2
JB ges_swp
bios13: JMP CS:ant_int13
ges_swp: CMP AH,2
JB bios13
CMP AH,16h
JE simcamb?
CMP AH,5
JA bios13
simcamb?: PUSH BX
LEA BX,info_E ; apuntar datos unidad
CMP CS:[BX].unidad,DL
JE tab_dat_ok
LEA BX,info_F
CMP CS:[BX].unidad,DL
JE tab_dat_ok
POP BX
JMP bios13
tab_dat_ok: CMP CS:[BX].controldrv,ON
MOV CS:[BX].controldrv,OFF ; simular cambio de disco
MOV CS:[BX].cambiodisco,ON ; en nueva unidad
POP BX
JNE bios13
STC
MOV AH,6
RET 2 ; y en la A: ó B:
ges_int13 ENDP
; ------------ Rutina de estrategia.
estrategia PROC FAR
MOV CS:pcab_pet_desp,BX
MOV CS:pcab_pet_segm,ES
RET
estrategia ENDP
; ------------ Rutina de interrupción.
interrupcion PROC FAR
STI
XPUSHA
XPUSH <DS, ES>
LDS BX,CS:pcab_peticion
MOV AL,[BX].orden_dsp ; AL = orden
MOV AH,0 ; AX = orden
CMP AL,13h
JBE orden_ok ; orden soportada
MOV AX,8103h ; orden desconocida
JMP exit_interr
orden_ok: SHL AX,1 ; orden = orden * 2
MOV DI,AX
ADD DI,OFFSET p_rutinas
LEA SI,drv_pvars
MOV AL,[BX].unidad_disco
CMP AL,CS:num_discos
JB disco_ok
MOV AX,8101h ; unidad desconocida
JMP exit_interr
disco_ok: MOV AH,0
SHL AX,1
ADD SI,AX
MOV SI,CS:[SI] ; SI -> BPB y juego variables
XPUSH <BX,DS>
CALL CS:[DI] ; ejecutar orden
XPOP <DS,BX>
exit_interr: MOV [BX].estado,AX
XPOP <ES, DS>
XPOPA
RET
interrupcion ENDP
; ------------ Las rutinas que controlan el dispositivo devuelven AX
; con la palabra de estado. Pueden cambiar todos los
; registros, incluídos los de segmento. A la entrada,
; DS:BX apunta a la cabecera de petición de solicitud y
; CS:SI al BPB y las variables de la unidad invocada.
read_nowait: ; órdenes ignoradas...
input_status:
input_flush:
output_status:
output_flush:
ioctl_output:
open:
close:
remove: ; dispositivo removible
retorno_ok: MOV AX,100h
RET
nofunc: MOV AX,8103h ; orden no soportada
RET
; --- Soporte IOCTL.
; - Implementa las funciones:
; 60h - Obtener parámetros del dispositivo
; 66h - Devolver nº de serie (para el DIR)
; 41h - Escritura de pista (para DISKCOPY)
; 61h - Lectura de pista (para DISKCOPY)
; - Ignora las funciones:
; 40h - Establecer parámetros del dispositivo
; 46h - Establecer nº de serie
; - Indica siempre que no está permitido:
; 42h - Formatear y verificar pista
; 62h - Verificar pista
; - Retorna error de "no soportado" en las demás
generic_ioctl: LDS BX,CS:pcab_peticion
CMP [BX].categoria_cod,8
JNE gen_ioctl_rtf
MOV AL,[BX].func_cod
CMP AL,60h ; soportado subcódigo 60h
JE get_devp
CMP AL,66h ; 66h
JE get_serie
CMP AL,46h ; 46h
JE set_serie
CMP AL,40h ; 40h
JE set_devp
CMP AL,41h ; 41h
JE wr_ioctl
CMP AL,61h ; y 61h
JE rd_ioctl
CMP AL,42h
JE ioct_nosup
CMP AL,62h
JE ioct_nosup
gen_ioctl_rtf: MOV AX,8103h ; orden no soportada
RET
get_devp: LES DI,[BX].ioctl_info ; orden 0860h invocada
TEST BYTE PTR ES:[DI],1
JZ devp ; no acceder a disco
XPUSHA
XPUSH <DS, ES>
CALL build_bpb ; actualizar datos
XPOP <ES, DS>
XPOPA
devp: INC SI
INC DI
MOV CX,38
PUSH CS
POP DS
CLD
REP MOVSB
set_devp: JMP gen_ioctl_ret ; subcódigo 40h ignorado
get_serie: LES DI,[BX].ioctl_info
ADD DI,2
PUSH CS
POP DS
LEA SI,[SI].numserie
MOV CX,23
CLD
REP MOVSB ; devolver nº serie y demás
set_serie: JMP gen_ioctl_ret ; no implementado cambiarlo
ioct_nosup: LES DI,[BX].ioctl_info
MOV BYTE PTR ES:[DI],2
MOV AX,8107h ; no soportado format/verify
RET
gen_ioctl_ret: MOV AX,100h ; Ok
RET
wr_ioctl: CALL ioctl_io_info
AND AX,AX
JNZ noserie
MOV AX,ES:[DI+39] ; actualizar número de
MOV CX,ES:[DI+41] ; serie en memoria
LEA DI,[SI].numserie
MOV CS:[DI],AX
MOV CS:[DI+2],CX
noserie: CALL io_drdos
CALL write
RET
rd_ioctl: CALL ioctl_io_info
CALL io_drdos
CALL read
RET
ioctl_io_info: LES DI,[BX].ioctl_info
MOV AX,ES:[DI+3] ; cilindro
MUL CS:[SI].num_cabezas
ADD AX,ES:[DI+1] ; cabezal
MUL CS:[SI].sectores_pista
ADD AX,ES:[DI+5] ; AX = sector inicial
MOV CX,ES:[DI+7] ; CX = número sectores
LES DI,ES:[DI+9] ; ES:DI = dirección E/S
PUSH CS
POP DS
LEA BX,pet_fantasma
MOV [BX].transfer_desp,DI
MOV [BX].transfer_segm,ES
MOV [BX].transfer_sect,CX ; nº sectores
MOV [BX].transfer_sini,AX ; primer sector
RET
; --- El diskcopy de DR-DOS 6.0+ empieza a copiar
; por el final, descendentemente. Para evitar la
; inevitable recalibración en cada pista al tener
; que ir una pista atrás, se copia al revés ;-)
io_drdos PROC
CMP drdos6,ON
JNE io_dr_ok
CMP [SI].sectores_pista,1
JNE io_dr_ok ; no es un disco 2MGUI
MOV AX,[SI].num_sect
SUB AX,[BX].transfer_sini
SUB AX,[BX].transfer_sect
MOV [BX].transfer_sini,AX ; sector opuesto
io_dr_ok: RET
io_drdos ENDP
; ------------ Rutina de detección de cambio de disco.
media_check: CMP CS:[SI].cambiodisco,ON
MOV CS:[SI].cambiodisco,OFF
MOV CS:[SI].controldrv,ON
MOV AL,0FFh ; supuesto cambio de disco
JE set_cambio ; disco recién formateado
MOV DL,CS:[SI].unidad
CALL leer_lin_camb ; en 1.2M/1.44M/2.88M...
JNZ set_cambio
MOV AL,1 ; sin cambio de disco
set_cambio: MOV [BX].cambio,AL
MOV AX,100h
RET
; ------------ Devolver ZF=1 si la línea de cambio de disco está
; inactiva. A la entrada, DL contiene la unidad. El
; motor es puesto en marcha y, si no lo estaba ya, la
; variable que indica lo que resta para detenerlo
; es llevada a su valor normal, por lo que el disco no
; tardará mucho en detenerse (incluso sin quizá haber
; acelerado aún).
leer_lin_camb PROC
XPUSHA ; *
PUSH DS
DDS
MOV AL,1
MOV CL,DL
SHL AL,CL ; bit de motor en 0..3
TEST DS:[3Fh],AL
JNZ rodando ; el motor ya está girando
CLC
CALL motor_off_cnt ; cuenta normal detención motor
rodando: MOV AH,DL
MOV CL,4
SHL AH,CL
OR AH,AL ; AH = byte BIOS
SHL AL,CL
OR AL,00001100b ; modo DMA, no hacer reset
OR AL,DL ; AL para reg. salida digital
MOV DX,FD_DOR
CLI
MOV DS:[3Fh],AH ; actualizar variable BIOS
OUT DX,AL ; arrancado motor en la unidad
ADD DX,5
DELAY
IN AL,DX ; leer línea de cambio de disco
STI
TEST AL,80h ; ZF=0 -> cambio de disco
POP DS
XPOPA ; *
RET
leer_lin_camb ENDP
; ------------ Como el disco no es de tipo IBM, el DOS no intentará
; leer el primer sector de la FAT después de invocar
; media_check y antes de invocar build_bpb.
build_bpb: XPUSH <CS, CS>
XPOP <DS, ES>
CALL abs_flush ; liquidar escritura pendiente
det_media: MOV [SI].cilindro,0
MOV [SI].cabezal,0
MOV [SI].vunidad1,0
MOV [SI].infb.vunidad2,0
STC
CALL reset_drv
CALL motor_ok
CALL seek_drv
MOV [SI].tsector,7 ; todo menos 2.88M
MOV CX,2
intenta_2mg: CLC
CALL reset_drv
XOR DX,DX ; empezar por alta densidad
densidad_2mg?: MOV [SI].vunidad1,DL
MOV [SI].infb.vunidad2,DH
CALL detect_2mgui
JE detectado_2mg
TEST status,80h
JNZ proc_bios ; ¿unidad no preparada?
ADD DX,0101h
CMP DL,3
JBE densidad_2mg? ; buscar densidad
LOOP intenta_2mg
JMP proc_bios
detectado_2mg: XPUSH <AX, BX, DI> ; *
MOV [SI].prot_esc,OFF ; supuesto no protegida...
CALL test_st3
JNC baja_lc
MOV [SI].prot_esc,ON ; protegida contra escritura
baja_lc: MOV [SI].cilindro,1
CALL seek_drv
MOV [SI].cilindro,0
CALL seek_drv ; bajar línea cambio de disco
MOV DX,FD_DIR
IN AL,DX ; leer línea de cambio de disco
MOV AH,80h
TEST AL,AH ; ZF=0 -> cambio de disco
XPOP <DI, BX, AX> ; *
JNZ no_listo
JMP s0_2mg_ok
proc_bios: MOV CX,3
intenta_bios: CALL detect_bios ; intentar acceso BIOS
JNC s0_bios_ok
LOOP intenta_bios
no_listo: CMP AH,80h
JE proc_err ; unidad no preparada
CLC
CALL reset_drv
CALL motor_ok
CALL seek_drv
MOV [SI].tsector,8 ; ¿será 2.88M?
MOV CX,2
intenta_2mg28: MOV DX,0303h ; sólo extraalta densidad
MOV [SI].vunidad1,DL
MOV [SI].infb.vunidad2,DH
CALL detect_2mgui
JE detectado_2mg
LOOP intenta_2mg28
MOV AL,20h ; indicar 'anomalía general'
proc_err: CALL errbios2dos
MOV [SI].modobios,ON ; disco no-2MGUI
RET
s0_2mg_ok: MOV [SI].modobios,OFF ; disco 2MGUI
MOV AL,7 ; log2 (16384) - 7 = 7
CMP [SI].infb.tpista1,16384
JBE tsec_ok
INC AL ; log2 (32768) - 7 = 8
tsec_ok: MOV [SI].tsector,AL
MOV DS,sbuffer
MOV BX,11
JMP s0_dos
s0_bios_ok: MOV [SI].modobios,ON ; disco no-2MGUI
MOV DS,sbuffer
MOV BX,11 ; offset en BOOT para el BPB
CMP WORD PTR [BX],512 ; ¿sectores de 512?
JE s0_dos
MOV AX,8107h ; 'medio físico desconocido'
RET
s0_dos: PUSH SI ; *
LEA DI,[SI].bytes_sector
LEA SI,[SI].numserie
XCHG SI,BX ; SI -> BPB del sector
MOV CX,17
XPUSH <SI, DI>
CLD
REP MOVSB ; construir BPB...
XPOP <DI, SI>
PUSH DI
MOV DI,BX
ADD SI,28 ; apuntar al nº serie y demás
MOV CX,23
REP MOVSB ; anotarlo
POP DI
POP SI ; *
MOV AX,ES:[SI].sectores_pista
MUL ES:[SI].num_cabezas
MOV CX,AX
MOV AX,ES:[SI].num_sect
XOR DX,DX
DIV CX
MOV ES:[SI].ioctl_pistas,AX
LDS BX,CS:pcab_peticion
MOV [BX].bpb_cmd_desp,DI ; nuevo BPB obtenido
MOV [BX].bpb_cmd_segm,CS
MOV AX,100h ; Ok.
RET
; --- Detectar un disco 2MGUI y devolver AX=tpista1
; y BX=tpista2
detect_2mgui: XPUSH <CX, DX>
MOV info_BUF.unidad,-1
MOV [SI].cilindro,0
MOV [SI].cabezal,0
MOV AX,sbuf512
MOV sbuffer,AX ; no usar EMS para esto
MOV [SI].infb.tpista1,512 ; con 512 bytes basta
MOV [SI].infb.mfrontera,86
PUSH ES ; *
MOV ES,sbuffer
MOV ES:[PINFOBOOT].idboot,0
POP ES ; *
CLC
CALL reset_drv
CALL motor_ok
CALL seek_drv
CALL lee_pista
CALL anotar_acceso
XPUSH <DS, ES, SI> ; **
PUSH DS
POP ES
MOV DS,sbuffer
LEA DI,[SI].infb
MOV SI,PINFOBOOT
MOV CX,(TYPE InfoBoot) - 2 ; respetar marca 0xAA55
CLD
REP MOVSB ; anotar información física BOOT
CMP WORD PTR DS:[PINFOBOOT].idboot,0AA55h ; ¿2MGUI?
XPOP <SI, ES, DS> ; **
XPOP <DX, CX> ; *
RET
; --- Detectar un disco estándar.
detect_bios: PUSH CX ; *
MOV AH,0
MOV DL,[SI].unidad
PUSHF
CALL CS:ant_int13 ; reset de disco
media_detect: MOV info_BUF.unidad,-1 ; invalidar buffer
PUSH ES ; **
MOV ES,sbuffer
XOR BX,BX
MOV DL,[SI].unidad
MOV DH,0
MOV CX,1
MOV AX,201h
PUSHF
CALL CS:ant_int13 ; leer sector de arranque
POP ES ; **
POP CX ; *
RET
; --- Comprobar ST3 para saber si el disco está
; protegido contra escritura.
test_st3 PROC
PUSH AX
MOV AL,4 ; comando para leer ST3
CALL fdc_write
JC st3_ok
MOV AL,[SI].cabezal
SHL AL,1
SHL AL,1
OR AL,[SI].unidad
CALL fdc_write ; enviar HD, US1, US0
JC st3_ok
CALL fdc_read
JC st3_ok
TEST AL,64 ; ¿protegido contra escritura?
JZ st3_ok
POP AX
STC
RET
st3_ok: POP AX
CLC
RET
test_st3 ENDP
; ------------ Realizar lecturas y escrituras.
read: MOV CS:verificar,OFF
MOV CS:orden,BIOS_READ
JMP prepara_io
write_verify: MOV CS:verificar,ON
MOV CS:orden,BIOS_WRITE
JMP prepara_io
write: MOV CS:verificar,OFF
MOV CS:orden,BIOS_WRITE
prepara_io PROC
LES DI,DWORD PTR [BX].transfer_desp ; dirección
MOV CX,[BX].transfer_sect ; nº sectores
MOV BX,[BX].transfer_sini ; primer sector
PUSH CS
POP DS
ADD BX,CX
JNC io_ok? ; último sector < 65536
io_no_ok: MOV AX,8108h ; error 'sector no encontrado'
RET
io_ok?: CMP BX,[SI].num_sect
JA io_no_ok ; sector final ¡fuera!
SUB BX,CX ; BX = primer sector
prepara_io ENDP
CMP [SI].modobios,ON
JE calcula_dir ; disco soportado por la BIOS
CMP ems_handle,0 ; disco soportado por 2MGUI
JNE acc_ems
JMP rwv2mgui ; no usada memoria EMS
acc_ems: MOV DX,ems_handle ; usada memoria EMS
MOV AH,47h
XPUSH <BX, CX, SI, DI>
INT 67h ; preservar el contexto
XPOP <DI, SI, CX, BX>
CMP AH,82h
JE acc_ems ; reintentar
AND AH,AH
MOV AX,810Ch ; fallo: anomalía general
JNZ rt_acc
CALL rwv2mgui
PUSH AX
rrst: MOV DX,CS:ems_handle ; ¡DS corrompido si error!
MOV AH,48h
INT 67h ; restaurar el contexto
CMP AH,82h
JE rrst ; reintentar; si falla, pasar
POP AX
rt_acc: RET
calcula_dir PROC
MOV AX,[SI].sectores_pista
MUL [SI].num_cabezas
XCHG AX,BX
XOR DX,DX
DIV BX ; AX = cilindro, DX = resto
MOV [SI].cilindro,AL
MOV AX,DX
XOR DX,DX
DIV [SI].sectores_pista ; AX = cabezal, DX = sector
MOV [SI].cabezal,AL
INC DL
MOV sector_ini,DL
calcula_dir ENDP
procesa_io PROC
MOV AX,[SI].sectores_pista
SUB AL,sector_ini
INC AL ; AX sectores hasta fin pista
final: CMP AL,CL
JBE nsect_fp
MOV AL,CL ; ¡no hay que acceder a tantos!
nsect_fp: MOV AH,sector_ini
ADD AH,AL
DEC AH
MOV sector_fin,AH ; sector ini/fin inicializados
PUSH DS ; *
XOR BX,BX
MOV DS,BX
LDS BX,DS:[1Eh*4] ; DS:BX -> tabla base disco
CMP [BX+4],AH
JAE ultsec_ok
MOV [BX+4],AH ; sectores/pista necesarios
ultsec_ok: MOV BYTE PTR DS:[BX+5],1 ; GAP R/W mínimo
POP DS ; *
XOR AH,AH
SUB CX,AX ; restar los que se accederán
PUSH CX
MOV CX,3 ; 3 intentos como máximo
reintentar_io: PUSH CX
MOV AH,orden
MOV CL,sector_ini
MOV AL,sector_fin
SUB AL,CL
INC AL
MOV CH,[SI].cilindro
MOV DH,[SI].cabezal
MOV DL,[SI].unidad
MOV BX,DI
PUSH AX
PUSHF
CALL ant_int13
POP BX
JC fallo_io ; ha habido fallo
CMP verificar,ON
CLC
JNE io_ok
MOV AH,4 ; verificar en write verify
MOV CL,sector_ini
MOV AL,sector_fin
SUB AL,CL
INC AL
MOV CH,[SI].cilindro
MOV DH,[SI].cabezal
MOV DL,[SI].unidad
MOV BX,DI
PUSH AX
PUSHF
CALL ant_int13
POP BX
JC fallo_io
JMP io_ok
fallo_io: POP CX
CMP AH,3
JE proc_io_nok ; protegido contra escritura
TEST AH,80h
JNZ proc_io_nok ; unidad no preparada
MOV AH,0
PUSH CX
PUSHF
CALL ant_int13 ; reset de disco
POP CX
LOOP reintentar_io
JMP proc_io_nok ; agotadas las oportunidades
io_ok: MOV AH,BL
SHL AH,1
MOV AL,0
ADD DI,AX ; ES:BX++
POP CX ; contador de intentos
POP CX ; sectores que restan
JCXZ fin_io ; ¿más sectores a transferir?
MOV sector_ini,1 ; ahora desde el primer sector
INC [SI].cabezal ; de la siguiente cara
MOV AX,[SI].num_cabezas
CMP [SI].cabezal,AL
JAE pr_step
JMP procesa_io
pr_step: MOV [SI].cabezal,0 ; o desde la primera cara
INC [SI].cilindro ; del siguiente cilindro
JMP procesa_io
fin_io: MOV AX,100h ; Ok.
RET
proc_io_nok: POP CX
LDS BX,pcab_peticion
MOV [BX].transfer_sect,0 ; movidos 0 sectores
MOV AH,1
MOV DL,CS:[SI].unidad
PUSHF
CALL CS:ant_int13 ; obtener código de error BIOS
CALL errbios2dos
RET ; retornar con código error DOS
procesa_io ENDP
; ------------ Traducir el error BIOS a código de error DOS.
errbios2dos PROC
MOV AL,0
CMP AH,3 ; ¿protegido contra escritura?
JE err_dos_ok
MOV AL,8
CMP AH,4 ; ¿sector no encontrado?
JE err_dos_ok
MOV AL,0Fh
CMP AH,6 ; ¿cambio de disco no permitido?
JE err_dos_ok
MOV AL,4
TEST AL,10h ; ¿error de CRC?
JNZ err_dos_ok
MOV AL,6
TEST AH,40h ; ¿fallo posicionando cabezal?
JNZ err_dos_ok
MOV AL,2
TEST AH,80h ; ¿unidad no preparada?
JNZ err_dos_ok
MOV AL,0Ch ; otro fallo: anomalía general
err_dos_ok: MOV AH,81h
RET
errbios2dos ENDP
; ------------ Lectura, escritura y verificación en disco 2MGUI.
; A la entrada, ES:DI=dirección, BX=sectini, CX=nsects.
rwv2mgui PROC
MOV AX,[SI].bytes_sector
MUL BX ; DX:AX = sector * tamaño
XPUSH <CX, AX, DX> ; *
MOV AX,[SI].infb.tpista1
MOV BL,[SI].infb.mfrontera
MOV BH,0
SHL BX,1
MUL BX ; DX:AX = tpista1 * frontera * 2
XPOP <CX, BX> ; * CX:BX = offset en disco
SUB BX,AX
SBB CX,DX
MOV [SI].cilindro,0 ; primera parte del disco
JC rwv_cil_ok
MOV AL,[SI].infb.mfrontera
MOV [SI].cilindro,AL ; segunda parte del disco
JMP rwv_off_ok
rwv_cil_ok: ADD BX,AX
ADC CX,DX ; restaurar offset
rwv_off_ok: MOV DX,CX
CALL tpistaAX
XCHG AX,BX ; offset en DX:AX, BX = tpista
POP CX ; *
SHL BX,1 ; BX = tpista * 2
DIV BX
ADD [SI].cilindro,AL ; cilindro inicial
MOV AX,DX
XOR DX,DX ; DX:AX = resto división
SHR BX,1
DIV BX
MOV [SI].cabezal,AL ; cabezal inicial
MOV off_ini,DX ; offset inicial
MOV AX,[SI].bytes_sector
MUL CX
MOV bytes,AX ; bytes a transferir
MOV CX,3 ; reintentos en caso de error
trans_mas: CMP bytes,0
JE fin_trans
PUSH CX
CALL tpistaAX
SUB AX,off_ini ; AX = bytes hasta final pista
CMP AX,bytes
JB ttrans_prep ; ocupa la pista hasta el final
MOV AX,bytes
ttrans_prep: ADD AX,off_ini
MOV off_fin,AX
CALL haz_io
POP CX
JNC ttrans_ok
CMP status,3 ; error grave (prot. escrit.)
JE err_trans
TEST status,80h
JNZ err_trans ; error grave (no preparada)
CALL reset_drv
LOOP trans_mas
JMP err_trans ; fin de reintentos
ttrans_ok: INC [SI].cabezal
CMP [SI].cabezal,2
JB incs_ok
MOV [SI].cabezal,0
INC [SI].cilindro
incs_ok: MOV AX,off_fin
SUB AX,off_ini
MOV off_ini,0
SUB bytes,AX
JMP trans_mas
err_trans: CLC
CALL motor_off_cnt ; cuenta detención motor
LDS BX,pcab_peticion
MOV [BX].transfer_sect,0 ; movidos 0 sectores
MOV AH,CS:status
CALL errbios2dos
RET
fin_trans: CLC
CALL motor_off_cnt ; cuenta detención motor
MOV AX,100h
RET
rwv2mgui ENDP
; --- Transferir desde off_ini a off_fin
haz_io PROC
CALL direcc_ems ; direccionar memoria EMS
JNC dirb_ok
JMP ret_io ; fallo
dirb_ok: CMP orden,BIOS_READ
JNE escribir
CALL leida?
JNC upd_ok
RET ; fallo en el flush
upd_ok: JZ ahorra_lect ; pista ya leída
CALL motor_ok
CALL seek_drv
CALL lee_pista
CALL anotar_acceso
JNC ahorra_lect
RET ; fallo al leer
ahorra_lect: MOV CX,off_fin
SUB CX,off_ini
XPUSH <DS, SI>
MOV SI,off_ini
MOV DS,sbuffer
CLD
REP MOVSB
XPOP <SI, DS>
CLC
JMP ret_io
escribir: CALL leida?
JC ret_io ; fallo en el flush
MOV CX,off_fin
SUB CX,off_ini
CALL tpistaAX
CMP CX,AX
JE escr_fast ; escribir pista completa
CALL leida?
JZ escr_fast ; pista ya en el buffer
CALL motor_ok
CALL seek_drv
CALL lee_pista ; parcial: prelectura
CALL anotar_acceso
JC ret_io
escr_fast: XPUSH <ES, DI> ; *
XPUSH <DS, SI> ; **
XPUSH <ES, DI>
XPOP <SI, DS>
MOV DI,CS:off_ini
MOV ES,CS:sbuffer
PUSH CX
CLD
REP MOVSB
POP CX
XPOP <SI, DS> ; **
PUSH AX ; **
MOV AL,[SI].cilindro
OR AL,[SI].cabezal
JNZ escr
XPUSH <SI, CX> ; ***
LEA SI,[SI].infb
MOV DI,PINFOBOOT
MOV CX,TYPE InfoBoot
CLD
REP MOVSB ; palabras de sólo lectura :-)
XPOP <CX, SI> ; ***
escr: POP AX ; **
XPOP <DI, ES> ; *
CALL escribir_pista ; "escribir" pista en disco
CALL anotar_acceso
JC ret_io
ADD DI,CX ; actualizar offset
CLC
ret_io: RET
haz_io ENDP
; --- Mapear memoria EMS si es utilizada.
direcc_ems PROC
PUSH SI
CMP ems_handle,0
JE seg_io_ok ; no usada EMS
MOV AX,DI
MOV CL,4
SHR AX,CL
MOV CX,ES
ADD AX,CX ; AX = dirección lineal ES:DI
MOV CX,marco_ems
ADD CX,1024 ; CX = base página 1
MOV BL,2 ; intentar usar página 2
MOV DX,2048 ; offset de la página física 2
CMP AX,CX
JB map_pag
XOR BL,BL ; usar la 0 para no colisionar
MOV DX,0 ; offset de la página física 0
map_pag: ADD DX,marco_ems
MOV sbuffer,DX
rmap_pag: MOV DX,ems_handle
MOV AL,BL ; página física
MOV AH,44h
MOV BX,0 ; primera página lógica
PUSH AX
INT 67h ; mapear página
POP BX
CMP AH,82h
JE rmap_pag ; reintentar
AND AH,AH
JNZ seg_io_ko
CMP tbuffer,16384
JBE seg_io_ok ; buffer de hasta 16K
INC BL ; siguiente página física
rmap2: MOV AL,BL
MOV AH,44h
MOV BX,1 ; segunda página lógica
MOV DX,ems_handle
PUSH AX
INT 67h ; mapear página
POP BX
CMP AH,82h
JE rmap2 ; reintentar
AND AH,AH
JNZ seg_io_ko
seg_io_ok: CLC ; Ok
POP SI
RET
seg_io_ko: MOV status,20h
STC ; fallo
POP SI
RET
direcc_ems ENDP
; --- Vaciar buffer a disco. Si se trabaja con EMS,
; previamente se mapea la memoria.
abs_flush PROC
CLI
CMP wrpend,ON
JE _abs_flush
STI
CLC
RET
_abs_flush: MOV wrpend,OFF
STI
CMP ems_handle,0
JNE flush_ems
JMP _flush_cache ; no usada memoria EMS
flush_ems: MOV DX,ems_handle ; usada memoria EMS
MOV AH,47h
INT 67h ; preservar el contexto
CMP AH,82h
JE flush_ems ; reintentar
AND AH,AH
JNZ absf_ret
CALL direcc_ems
CALL _flush_cache
PUSH AX
rrst2: MOV DX,ems_handle
MOV AH,48h
INT 67h ; restaurar el contexto
CMP AH,82h
JE rrst2 ; reintentar
POP AX
absf_ret: RET
abs_flush ENDP
; --- Vaciar buffer a disco. La escritura efectiva se
; retarda para reducir accesos redundantes.
flush_cache PROC
CLI
CMP wrpend,ON
JE _flush_cache
STI
CLC
RET
_flush_cache: MOV wrpend,OFF
STI
PUSH SI
LEA SI,info_BUF
CMP [SI].unidad,-1
JE fc_ret
CALL motor_ok
CALL seek_drv
CALL escribe_pista
CALL anotar_acceso
fc_ret: POP SI
RET
flush_cache ENDP
; --- Simular escritura en disco, aunque realmente se
; hará normalmente más tarde ("delayed write") a
; menos que esté activa la verificación.
escribir_pista PROC
CMP [SI].prot_esc,ON
JNE wr_posible
MOV status,3 ; protegida de escritura
STC
RET
wr_posible: CMP verificar,ON
JE wr_fisico ; verificación activa...
CMP cachewr,ON
JE delayed_wr
wr_fisico: CALL motor_ok ; caché desactivada
CALL seek_drv
CALL escribe_pista
JC wr_fs_ret
CMP verificar,OFF
JE wr_fs_ret ; CF=0
CALL lee_pista ; detectar posible fallo
wr_fs_ret: RET
delayed_wr: MOV expiraw,W_CACHE_TM ; recargar contador de
MOV wrpend,ON ; tiempo para escritura
CLC ; retardada
RET
escribir_pista ENDP
; ------------ Comprobar si la pista está en el buffer. En caso de
; estarlo se retorna con ZF=1. Si no estaba aún, se
; vacía el contenido del buffer (si aún no estaba
; escrito en disco) en previsión de una futura
; lectura, retornando con ZF=0 (ó CF=1 si hay error
; al escribir).
leida? PROC
PUSH AX
MOV AL,info_BUF.unidad
CMP AL,[SI].unidad
JNE no_leida ; es en otra unidad
MOV AL,[SI].cilindro
CMP AL,info_BUF.cilindro
JNE no_leida
MOV AH,[SI].cabezal
CMP AH,info_BUF.cabezal
JNE no_leida ; es en otro cilindro/cabezal
POP AX
RET ; está en el buffer CF=0, ZF=1
no_leida: CALL flush_cache
JC ret_leida? ; CF = 1 si error en el flush
CMP SP,0
CLC ; CF = ZF = 0
ret_leida?: POP AX
RET ; pista no leída
leida? ENDP
; --- Tomar nota de la pista que ocupa el buffer para
; evitar accesos a disco redundantes. A la entrada,
; CF=1 señala error e invalida el buffer. Se anotan
; también los demás parámetros, necesarios para una
; posible escritura desde la interrupción periódica.
anotar_acceso PROC
MOV info_BUF.unidad,-1 ; invalidar buffer si error
JC anotado
XPUSH <CX, SI, DI, ES>
PUSH DS
POP ES
LEA DI,info_BUF
MOV CX,TYPE info_unidad
CLD
REP MOVSB
XPOP <ES, DI, SI, CX>
CLC
anotado: RET
anotar_acceso ENDP
; ------------ Devolver el tamaño de la pista según la posición
; del cabezal (necesario en discos /DH).
tpistaAX PROC
MOV AL,CS:[SI].infb.mfrontera
CMP CS:[SI].cilindro,AL
MOV AX,CS:[SI].infb.tpista1
JB tpis_ax
MOV AX,CS:[SI].infb.tpista2
tpis_ax: RET
tpistaAX ENDP
; ------------ Asegurar que el motor está en marcha.
motor_ok PROC
XPUSHA ; *
PUSH DS ; **
MOV BX,40h
PUSH BX
POP DS
MOV CH,255-18 ; CH = 255 - 1 segundo
CLI
MOV CL,CS:[SI].unidad
MOV AL,1
SHL AL,CL
TEST [BX-1],AL ; ¿motor en marcha?
JZ arrancarlo ; arrancarlo
CMP [BX],CH ; Si encendido y acelerado...
JBE ok_motor ; ...seguir
arrancarlo: MOV AH,CL
MOV CL,4
SHL AH,CL ; unidad << 4
OR AL,AH
MOV [BX-1],AL ; nuevo estado motores
MOV BYTE PTR [BX],255 ; asegurar que no se pare
MOV DX,FD_DOR ; registro de salida digital
ADD CL,CS:[SI].unidad
MOV AL,1
SHL AL,CL ; colocar bit del motor
OR AL,CS:[SI].unidad ; seleccionar unidad
OR AL,00001100b ; modo DMA, no hacer reset
OUT DX,AL ; poner en marcha el motor
STI
MOV AX,90FDh
CLC
INT 15h ; permitir multitarea
JC ok_motor ; timeout
MOV AX,1000 ; 1 segundo aceleración
CALL retardo ; esperar aceleración disco
ok_motor: MOV [BX],CH ; cuenta máxima detención motor
STI ; sin forzar futura aceleración
POP DS ; **
XPOPA ; *
RET
motor_ok ENDP
; ------------ Establecer modalidad de operación del controlador
; y poner el motor en marcha. Si CF=1 se le da tiempo
; además a la unidad para que acelere.
reset_drv PROC
XPUSHA
CALL motor_off_cnt ; cuenta detención motor
STC
CALL set_rate ; velocidad correcta
MOV CL,[SI].unidad
MOV AL,CL ; unidad seleccionada
SHL AL,1
SHL AL,1
SHL AL,1
SHL AL,1
MOV AH,1 ; bit de motor
SHL AH,CL ; colocar dicho bit
OR AL,AH
PUSH DS ; *
DDS
CLI
MOV DS:[3Fh],AL
AND BYTE PTR DS:[3Eh],70h ; bit IRQ=0 y recalibrar
POP DS ; *
SHL AL,1
SHL AL,1
SHL AL,1
SHL AL,1 ; bits motor en nibble alto
OR AL,CL ; seleccionar unidad
OR AL,00001000b ; interrupciones+DMA y reset
MOV DX,FD_DOR ; registro de salida digital
OUT DX,AL ; señal de reset
CALL fdc_respiro ; tiempo reconocer reset en 486
OR AL,00000100b
OUT DX,AL ; fin de señal de reset
CALL reset_DMA
CALL reset_irq
CALL espera_int ; rehabilitará interrupciones
AND status,7Fh ; perdonar controladora rara
MOV AL,8
CALL fdc_write ; comando 'leer estado int...'
CALL fdc_read
CALL fdc_read
STC
CALL envia_specify ; comando 'specify' adecuado
XPOPA
RET
reset_drv ENDP
; ------------ Reset "blando" para que el FDC deje de enviar/recibir.
reset_fast PROC
XPUSHA
MOV CL,[SI].unidad
ADD CL,4
MOV AL,1
SHL AL,CL ; bits motor en nibble alto
OR AL,[SI].unidad ; seleccionar unidad
OR AL,00001000b ; interrupciones+DMA y reset
MOV DX,FD_DOR ; registro de salida digital
CLI
OUT DX,AL ; señal de reset
CALL fdc_respiro ; tiempo reconocer reset en 486
OR AL,00000100b
OUT DX,AL ; fin de señal de reset
CALL reset_DMA
CALL reset_irq
CALL espera_int ; rehabilitará interrupciones
AND status,7Fh ; perdonar controladora rara
MOV AL,8
CALL fdc_write ; comando 'leer estado int...'
CALL fdc_read
CALL fdc_read
STC
CALL envia_specify ; comando 'specify' con DMA
XPOPA
RET
reset_fast ENDP
; ------------ Desactivar el modo DMA si procede (antes de leer o
; escribir). Además de enviar al FDC el comando specify
; adecuado, se selecciona el modo no-DMA (si fuera
; preciso) en el registro de salida digital (necesario en
; algunas controladoras).
dma_si_o_no PROC
CMP modoDMA,ON
JE dmsnret
XPUSHA
MOV CL,[SI].unidad
ADD CL,4
MOV AL,1
SHL AL,CL ; bits motor en nibble alto
OR AL,[SI].unidad ; seleccionar unidad
OR AL,00000100b ; modo no-DMA, sin reset
MOV DX,FD_DOR
OUT DX,AL
CLC
CALL envia_specify ; comando 'specify' adecuado
XPOPA
dmsnret: RET
dma_si_o_no ENDP
; ------------ Inhibir y borrar petición en el canal 2 de DMA. No es
; realmente necesario, porque la controladora ya no
; transmite más después del reset, es sólo por seguridad.
reset_DMA PROC
PUSH AX
MOV AL,2
DELAY
OUT 09h,AL ; borrar petición por software
MOV AL,6
DELAY
OUT 0Ah,AL ; inhibir canal 2
POP AX
RET
reset_DMA ENDP
; ------------ Borrar bit de interrupción pendiente para asegurar
; su correcta detección si llegó antes alguna inesperada,
; aunque realmente no tiene por qué suceder.
reset_irq PROC
PUSHF
PUSH DS
DDS
AND BYTE PTR DS:[3Eh],7Fh ; asegurar detección int.
POP DS
POPF
RET
reset_irq ENDP
; ------------ Enviar comando specify a la controladora. El step-rate
; se selecciona según la densidad, para evitar un sonido
; extraño al posicionar o recalibrar el cabezal. A la
; entrada, CF=1 selecciona modo DMA y 0 no-DMA
envia_specify PROC
PUSH AX ; *
PUSHF ; **
PUSH DS
DDS
MOV AH,DS:[8Bh]
POP DS
MOV AL,3 ; comando 'specify'
CALL fdc_write
MOV AL,0BFh ; step rate para 500 kbps
AND AH,11000000b
JZ spec1_ok
MOV AL,0AFh ; step rate para 1 Mbps
CMP AH,11000000b
JE spec1_ok
MOV AL,0DFh ; step rate para 250/300 Kbps
spec1_ok: CALL fdc_write
MOV AL,2 ; modo DMA
POPF ; **
JC spec2_ok
MOV AL,3 ; modo no DMA
spec2_ok: CALL fdc_write
POP AX ; *
RET
envia_specify ENDP
; ------------ Recargar cuenta para la detención del motor. Si CF=1 al
; entrar, se establece la mayor cuenta posible; en caso
; contrario, se pone el valor normal de la tabla base.
motor_off_cnt PROC
XPUSHA
PUSH DS
MOV AL,0FFh ; valor máximo
JC motor_off_ok
XOR BX,BX
MOV DS,BX
LDS BX,DWORD PTR DS:[1Eh*4] ; DS:BX -> INT 1Eh
MOV AL,[BX+2] ; byte 2 tabla base disco
motor_off_ok: DDS
MOV BYTE PTR DS:[40h],AL ; cuenta parada motor
POP DS
XPOPA
RET
motor_off_cnt ENDP
; ------------ Llevar el cabezal a la pista indicada, recalibrando si
; hubo un reset (se invocó la función 0 de la INT 13h o
; se ejecutó reset_drv) antes de esta operación. Primero
; se selecciona la velocidad de transferencia y se borra
; el resultado de cualquier operación anterior, para que
; todo quede listo para el próximo acceso a disco.
seek_drv PROC
XPUSHA
CLC
CALL set_rate ; velocidad / borrar resultados
STC
CALL envia_specify ; comando 'specify' adecuado
MOV AH,1
MOV CL,[SI].unidad
SHL AH,CL ; AH = 1 (A:) ó 2 (B:)
PUSH DS
DDS
TEST AH,DS:[3Eh]
POP DS
JNZ do_seek ; la unidad ya fue recalibrada
CALL recalibrar
JC fallo_seek ; fallo al recalibrar
do_seek: CMP [SI].cilindro,0
JNE seek_deveras
CALL recalibrar ; ir a la pista 0
JMP seek_ok
seek_deveras: MOV BX,94h
ADD BL,[SI].unidad
MOV AL,[SI].cilindro
PUSH DS ; *
DDS
MOV CH,[BX] ; cilindro previo
MOV [BX],AL ; nuevo cilindro
POP DS ; *
CMP AL,CH
JE seek_ret ; seek innecesario
hacer_seek: SUB AL,CH
JC seek_neg ; seek hacia atrás
seek_pos: CALL seek_fisico ; seek hacia delante
JC fallo_seek
JMP seek_ok
seek_neg: ADD AL,CH
CALL recalibrar ; ir a la pista 0
MOV [SI].cilindro,AL
JC fallo_seek
JMP seek_deveras ; y luego a donde sea
seek_ok: MOV AX,15 ; 15 milisegundos
CALL retardo ; esperar asentamiento cabezal
seek_ret: CLC ; retornar con éxito
ret_seek: XPOPA
RET
fallo_seek: XPOPA
STC ; retornar indicando fallo
RET
; --- Como el registro interno de la controladora se
; pone a 0 tras el reset, el seek es por importe
; de la diferencia entre el cilindro origen y el
; destino (para retroceder se recalibra antes).
seek_fisico: MOV CH,AL ; magnitud del "salto"
MOV AL,0Fh
CALL fdc_write ; comando 'seek'
JC sk_fs_nok
MOV AL,[SI].cabezal
SHL AL,1
SHL AL,1
OR AL,[SI].unidad
CALL fdc_write ; enviar HD, US1, US0
MOV AL,CH ; cilindro aparente
CALL reset_irq
CALL fdc_write ; enviar cilindro
CALL espera_int ; esperar interrupción
JC sk_fs_nok
MOV AL,8
CALL fdc_write ; comando 'leer estado int...'
JC sk_fs_nok
CALL fdc_read ; leer registro de estado 0
JC sk_fs_nok
MOV AH,AL
CALL fdc_read ; leer cilindro actual
TEST AH,11000000b ; comprobar ST0
JNZ sk_fs_nok
sk_fs_ok: CLC
RET
sk_fs_nok: STC
RET
seek_drv ENDP
; ------------ Establecer velocidad de transferencia correcta si aún
; no ha sido seleccionada y borrar el resultado de otra
; operación previa. Si CF=1 al entrar, la velocidad se
; establece incondicionalmente (por si la variable de
; la BIOS no está correctamente asignada).
set_rate PROC
XPUSHA
PUSHF
MOV AL,[SI].infb.mfrontera
CMP [SI].cilindro,AL
MOV AL,[SI].vunidad1 ; velocidad primera parte
MOV AH,[SI].infb.vunidad2 ; velocidad segunda parte
JB vel_ok
MOV AL,AH
vel_ok: POPF
PUSH DS ; *
DDS
JC abs_rate
MOV AH,DS:[8Bh]
MOV CL,6
SHR AH,CL ; aislar bits de velocidad
CMP AL,AH
JE vel_set ; velocidad ya seleccionada
abs_rate: MOV DX,FD_DCR
OUT DX,AL ; seleccionarla
MOV CL,6
SHL AL,CL
AND BYTE PTR DS:[8Bh],00111111b
OR DS:[8Bh],AL
vel_set: POP DS ; *
LEA DI,status
MOV CX,8
borra_status: MOV [DI],CH ; borrar información de estado
INC DI
LOOP borra_status
XPOPA
RET
set_rate ENDP
; ------------ Recalibrar la unidad (si hay error se intenta otra vez
; para el caso de que deba moverse más de 77 pistas).
recalibrar PROC
XPUSHA
MOV BX,94h
ADD BL,[SI].unidad
PUSH DS ; *
DDS
MOV [BX],BH ; pista actual = 0
POP DS ; *
MOV CX,2 ; dos veces como mucho
recalibra: MOV AL,7
CALL fdc_write ; comando de 'recalibrado'
JC fallo_recal
MOV AL,[SI].cabezal
SHL AL,1
SHL AL,1
OR AL,[SI].unidad
CALL reset_irq
CALL fdc_write ; enviar HD, US1, US0
JC fallo_recal
CALL espera_int ; esperar interrupción
JC fallo_recal
MOV AL,8
CALL fdc_write ; comando 'leer estado int...'
JC fallo_recal
CALL fdc_read ; leer registro de estado 0
JC fallo_recal
MOV AH,AL
CALL fdc_read ; leer cilindro actual
XOR AH,00100000b ; bajar bit de 'seek end'
TEST AH,11110000b ; comprobar resultado y ST0
JNZ fallo_recal ; sin 'seek end' o TRK0
MOV AX,1 ; pausa de 1 ms
CALL retardo
JMP recal_ret
fallo_recal: CALL reset_fast
LOOP recalibra ; reintentar comando
STC ; condición de fallo
XPOPA
RET
recal_ret: MOV AH,1
MOV CL,[SI].unidad
SHL AH,CL ; AH = 1 (A:) ó 2 (B:)
MOV BX,94h
ADD BL,CL
PUSH DS
DDS
OR DS:[3Eh],AH ; unidad ya recalibrada
POP DS
CLC
XPOPA
RET
recalibrar ENDP
; ------------ Escribir pista. En modo test (gaprw == -1) se escriben
; sólo los bytes de la pista (sin almacenar el checksum
; ni el GAP anti-FIFO).
escribe_pista PROC
XPUSHA
CALL dma_si_o_no ; modo no-DMA si es preciso
PUSH ES ; *
MOV ES,sbuffer
CALL tpistaAX
MOV CX,AX
XOR BX,BX
XOR AX,AX
MOV DX,2
SHR CX,1
PUSHF
calc_chk: ADD AX,ES:[BX] ; calcular checksum en AX
ADD BX,DX
LOOP calc_chk
POPF
JNC fcalc_chk
ADD AL,ES:[BX] ; nº de bytes impar
ADC AH,0
INC BX
fcalc_chk: MOV CX,gaprw
CMP CX,-1
JE wfis1
NOT AX
MOV ES:[BX],AX ; NOT (checksum)
JCXZ wfis1
MOV AL,0
gapw: MOV ES:[BX+2],AL ; "GAP"
INC BX
LOOP gapw
wfis1: POP ES ; *
CALL tpistaAX
CMP gaprw,-1 ; ¿escritura de test?
JE wfis2
ADD AX,SYSBYTES
ADD AX,gaprw ; bytes extra tras datos
wfis2: MOV CX,AX
DEC CX ; bytes totales - 1
MOV AX,sbuffer
XOR DI,DI
CALL calc_dir_DMA ; AX:DI -> base BX y página AH
MOV AL,F_WRITE ; modo DMA necesario
CALL prepara_DMA
MOV AL,11000101b ; comando de escritura del FDC
CALL fdc_write
JC escr_ko
MOV AL,[SI].cabezal
SHL AL,1
SHL AL,1
OR AL,[SI].unidad
CALL fdc_write ; byte 1 de la orden
MOV AL,[SI].cilindro
CALL fdc_write ; enviar cilindro
MOV AL,[SI].cabezal
CALL fdc_write ; enviar cabezal
MOV AL,0
CALL fdc_write ; enviar nº sector
MOV AL,[SI].tsector
CALL fdc_write ; longitud sector
MOV AL,0
CALL fdc_write ; último sector
MOV AL,8
CALL fdc_write ; GAP no usado, pero...
MOV AL,128
CLI ; ir inhibiéndolas ya
CALL fdc_write ; tamaño sector si longitud=0
CALL espia_dma
JMP escr_ret
escr_ko: STC ; indicar fallo
escr_ret: XPOPA
RET
escribe_pista ENDP
; ------------ Leer pista. En modo test (gaprw == -1) no se leen los
; bytes finales con el checksum (aunque sí se comparan al
; final: el error se debe desechar y comprobar el éxito
; de otra manera).
lee_pista PROC
XPUSHA
CALL dma_si_o_no ; modo no-DMA si es preciso
CALL tpistaAX
CMP gaprw,-1
JE rfis ; lectura de test
ADD AX,SYSBYTES
ADD AX,gaprw ; bytes extra tras datos
rfis: MOV CX,AX
DEC CX ; bytes totales - 1
MOV AX,sbuffer
XOR DI,DI
CALL calc_dir_DMA ; AX:DI -> base BX y página AH
MOV AL,F_READ ; modo DMA necesario
CALL prepara_DMA
MOV AL,11100110b ; comando de lectura del FDC
CALL fdc_write
MOV DL,20h
JC leer_err
MOV AL,[SI].cabezal
SHL AL,1
SHL AL,1
OR AL,[SI].unidad
CALL fdc_write ; byte 1 de la orden
MOV AL,[SI].cilindro
CALL fdc_write ; enviar cilindro
MOV AL,[SI].cabezal
CALL fdc_write ; enviar cabezal
MOV AL,0
CALL fdc_write ; enviar nº sector
MOV AL,[SI].tsector
CALL fdc_write ; longitud sector
MOV AL,0
CALL fdc_write ; último sector
MOV AL,8
CALL fdc_write ; GAP no usado, pero...
MOV AL,128
CLI ; ir inhibiéndolas ya
CALL fdc_write ; tamaño sector si longitud=0
CALL espia_dma
JC leer_ret ; hubo error
PUSH ES ; *
MOV ES,sbuffer
CALL tpistaAX
MOV CX,AX
XOR BX,BX
XOR AX,AX
MOV DX,2
SHR CX,1
PUSHF
test_chk: ADD AX,ES:[BX] ; calcular checksum en AX
ADD BX,DX
LOOP test_chk
POPF
JNC ftest_chk
ADD AL,ES:[BX] ; nº de bytes impar
ADC AH,0
INC BX
ftest_chk: NOT AX ; NOT (checksum)
MOV CX,ES:[BX] ; checksum en disco en CX
POP ES ; *
MOV DL,10h ; 'error de CRC'
CMP AX,CX
JNE leer_err
CLC ; Ok
JMP leer_ret
leer_err: OR status,DL
STC ; indicar fallo
leer_ret: XPOPA
RET
lee_pista ENDP
; ------------ Cuando el DMA acabe... resetear controladora. A la
; entrada, las interrupciones deben estar inhibidas.
; Si no se emplea el DMA ... se resetea cuando se han
; enviado/recibido directamente los bytes necesarios.
; Se reprograma el 8254 para asegurar a ultranza que
; produce las 18,2 irqs/seg habituales y para contar
; exactamente el tiempo que pasará en esta rutina: la
; pérdida de exactitud que supone recargar la cuenta
; no se puede comparar ni remotamente a la de tener
; las interrupciones inhibidas ;-)
espia_dma PROC
XPUSH <ES, DI> ; *
MOV ES,sbuffer
MOV AL,00010110b
OUT 43h,AL ; 8254: cnt0 byte bajo
MOV AL,0
DELAY
OUT 40h,AL ; asegurar recarga = 0000h
MOV AL,00100110b
DELAY
OUT 43h,AL ; 8254: cnt0 byte alto
MOV AL,0
DELAY
OUT 40h,AL ; asegurar recarga = 0000h
DELAY
IN AL,40h
MOV BL,AL ; estado de la cuenta alta
MOV DX,FD_STATUS
MOV CX,TICSTIMEOUT ; constante de timeout
CMP modoDMA,ON
JE wait_dma
XOR DI,DI ; ES:DI -> sbuffer
MOV AH,BL
MOV BX,bytesIO
CMP sentidoIO,F_READ
JE rd_nodma
wr_nodma: IN AL,DX ; transferencia sin DMA
TEST AL,10000000b
JNZ wr_byte
IN AL,40h
CMP AL,AH
JE wr_nodma ; no han pasado 256/1193180 seg
MOV AH,AL
LOOP wr_nodma
JMP io_timeout
wr_byte: TEST AL,01000000b ; ¿fdc->cpu en vez de cpu->fdc?
JNZ io_result ; así es: fallo en escritura
MOV AL,ES:[DI]
INC DX ; apuntar al registro de datos
OUT DX,AL ; escribir byte de la pista
DEC DX
INC DI
DEC BX
JNZ wr_nodma ; hasta acabar pista
JMP io_fin
rd_nodma: IN AL,DX ; transferencia sin DMA
TEST AL,10000000b
JNZ rd_byte
IN AL,40h
CMP AL,AH
JE rd_nodma ; no han pasado 256/1193180 seg
MOV AH,AL
LOOP rd_nodma
JMP io_timeout
rd_byte: TEST AL,00100000b ; ¿fase de ejecución?
JZ io_result ; no: fallo en lectura
INC DX ; apuntar al registro de datos
IN AL,DX ; leer byte de la pista
DEC DX
STOSB
DEC BX
JNZ rd_nodma ; hasta acabar pista
JMP io_fin
wait_dma: IN AL,DX ; transferencia con DMA
XOR AL,11000000b
TEST AL,11000000b
JZ io_result ; hay resultados del FDC
IN AL,5
MOV AH,AL
IN AL,5 ; contador del canal 2
CMP AX,-1
JE io_fin ; fin de la cuenta del DMA
IN AL,40h
CMP AL,BL
JE wait_dma ; no han pasado 256/1193180 seg
MOV BL,AL
LOOP wait_dma
io_timeout: CALL reset_fast ; habilita ints (quita timeout)
MOV status,80h ; recuperar condición timeout
JMP io_ret_nok
io_fin: IN AL,DX
XOR AL,11000000b
TEST AL,11000000b
JZ io_result ; hay resultados del FDC
CALL reset_fast ; habilita ints
JMP io_ret_ok ; siempre ok
io_result: CALL reset_DMA ; por si acaso
STI
LEA BX,fdc_result
PUSH CX ; ** no corromper CX
MOV CX,7
io_leeres: CALL fdc_read ; leyendo resultados
MOV [BX],AL
INC BX
LOOP io_leeres
POP CX ; **
CMP modoDMA,ON
JE io_ret_nok
MOV AL,status ; preservar resultado
CALL reset_fast ; volver al modo DMA+INT
MOV status,AL ; restaurar resultado
io_ret_nok: CALL ajustar_hora
XPOP <DI, ES> ; *
STC ; retorno con error
CALL set_err
RET
io_ret_ok: XPOP <DI, ES> ; *
CALL ajustar_hora
CLC ; retorno Ok
RET
espia_dma ENDP
; ------------ Leer el reloj de tiempo real y actualizar la hora.
; El acceso a disco con las interrupciones inhibidas
; retrasa brutalmente la hora. Si es un PC/XT, a la
; entrada CX indica las veces que le quedaban por cambiar
; a la parte alta de la cuenta del contador 0 del 8253
; desde que se inhibieron las interrupciones para que
; se hubiera producido un timeout.
ajustar_hora PROC
XPUSHA
CMP CS:pcxt,ON
JE ajuste_burdo ; jeje, pobrecillo XT
CALL leer_RTC
JNC actualiza_tm ; no hay actualización en curso
JMP fin_ajuste
ajuste_burdo: SUB CX,TICSTIMEOUT
NEG CX ; tiempo transcurrido apróx.
ADD CX,48 ; redondeo
MOV CL,CH
MOV CH,0
SHR CX,1 ; expresado en 1/18,2-avos seg.
PUSH DS
DDS
ADD CX,DS:[6Ch]
MOV BX,DS:[6Eh]
ADC BX,0
POP DS
JMP ajusta_bios
actualiza_tm: MOV AL,DH ; segundos en BCD
CALL convdec ; BCD (AL) -> decimal (AX)
PUSH AX ; almacenar segundos
MOV AL,CL ; minuto en BCD
CALL convdec ; BCD (AL) -> decimal (AX)
PUSH AX ; almacenar minuto
MOV AL,CH ; hora en BCD
CALL convdec ; BCD (AL) -> decimal (AX)
MOV BX,60
MUL BL ; AX = hora*60
POP DX
ADD AX,DX ; AX = hora*60+minuto
MUL BX ; DX:AX = (hora*60+minuto)*60
POP CX
ADD CX,AX ; añadir segundos
ADC DX,0
MOV BX,DX ; BX:CX segundos totales
MOV SI,CX
MOV DI,BX ; DI:SI segundos totales
MOV AX,18 ; (1193180 DIV 65536)
CALL mult32x16 ; DI:SI = seg * 18
XCHG SI,CX
XCHG DI,BX ; BX:CX:XX = seg * 18 * 65536
MOV AX,13532 ; (1193180 MOD 65536)
CALL mult32x16
ADD CX,DI
ADC BX,0 ; BX:CX:SI = seg * 1193180
ajusta_bios: PUSH DS
DDS
CMP BX,24
JNE medianoche_ok
CMP CX,176
JB medianoche_ok
XOR BX,BX
SUB CX,176
INC BYTE PTR DS:[70h] ; paso 23:59:59 --> 00:00:00
medianoche_ok: MOV DS:[6Ch],CX
MOV DS:[6Eh],BX ; BX:CX = seg * 1193180 / 65536
POP DS
fin_ajuste: XPOPA
RET
convdec: MOV AH,AL ; BCD en AL --> decimal en AX
SHR AH,1
SHR AH,1
SHR AH,1
SHR AH,1
AND AL,15
AAD
RET
ajustar_hora ENDP
; --- Obtener la hora del reloj de tiempo real SIN BIOS.
leer_RTC PROC
MOV AL,0Ah ; registro de estado A
OUT 70h,AL
DELAY
IN AL,71h
TEST AL,128
JNZ tm_nok ; en medio de actualización
MOV AL,4
DELAY
OUT 70h,AL
DELAY
IN AL,71h
MOV CH,AL ; hora
MOV AL,2
DELAY
OUT 70h,AL
DELAY
IN AL,71h
MOV CL,AL ; minuto
MOV AL,0
DELAY
OUT 70h,AL
DELAY
IN AL,71h
MOV DH,AL ; segundo
CLC
RET
tm_nok: STC
RET
leer_RTC ENDP
; ------------ Rutina para multiplicar números de 32 por números de 16
; bits generando resultado de 48 bits: DXDISI = DISI * AX
mult32x16 PROC
PUSH AX
XCHG SI,AX ; multiplicador en SI
MUL SI ; AX (parte baja) * SI --> DXAX
XPUSH <DX, AX> ; preservar resultado parcial
MOV AX,DI
MUL SI ; AX (parte alta) * SI --> DXAX
XPOP <SI, DI> ; parte baja y media del resultado
ADD DI,AX ; acumular resultado intermedio
ADC DX,0 ; arrastrar posible acarreo
POP AX
RET
mult32x16 ENDP
; ------------ Devolver en AH la página de DMA y en BX la base. A la
; entrada, AX:DI -> dirección de memoria.
calc_dir_DMA PROC
PUSH DX
MOV BX,16
MUL BX
ADD AX,DI
ADC DX,0 ; DX:AX = dirección 20 bits
MOV BX,AX ; base en BX
MOV AH,DL ; página
dir_DMA_ok: POP DX
RET
calc_dir_DMA ENDP
; ------------ Determinar el tipo de error producido en el acceso.
set_err PROC
XPUSHA
JNC err_ret ; no hay error
CMP status,0 ; ¿'status' ya asignado?
JNE err_retc ; no cambiarlo si es así
MOV AL,BYTE PTR fdc_result+1
AND AL,10110111b ; aislar condiciones de test
LEA BX,lista_errs
MOV CX,9
busca_err: MOV AH,[BX] ; código de error BIOS
SHL AL,1
JC err_ok ; es ese error
INC BX
LOOP busca_err ; buscar otro error
err_ok: OR status,AH
err_retc: STC ; condición de error
err_ret: XPOPA
RET
set_err ENDP
; ------------ Esperar interrupción de disquete durante casi 2
; segundos antes de considerar que ha sido un fracaso.
espera_int PROC
STI
XPUSHA
XPUSH <DS, 40h>
POP DS
MOV AX,9001h
CLC
INT 15h ; permitir multitarea
JC timeout_int
MOV AH,0FFh
esperar_int: CMP AL,DS:[6Ch]
JE mira_int
MOV AL,DS:[6Ch]
INC AH
CMP AH,37 ; ¿más de 2 segundos?
JB mira_int
timeout_int: OR CS:status,80h ; timeout
STC
JMP fin_espera
mira_int: TEST BYTE PTR DS:[3Eh],80h
JZ esperar_int
AND BYTE PTR DS:[3Eh],7Fh ; CF=0
fin_espera: POP DS
XPOPA
RET
espera_int ENDP
; ------------ Preparar DMA para E/S. A la entrada, BX = dirección de
; base, AH = registro de página y CX = nº bytes - 1.
prepara_DMA PROC
CMP modoDMA,ON
JE _prepara_DMA
MOV sentidoIO,AL
MOV bytesIO,CX
INC bytesIO
RET ; modo NO-DMA
_prepara_DMA: PUSH AX
CLI
OUT 0Bh,AL ; registro de modo del DMA
MOV AL,0
DELAY
OUT 0Ch,AL ; clear first/last flip-flop
MOV AL,BL
DELAY
OUT 4,AL
MOV AL,BH
DELAY
OUT 4,AL ; enviada dirección base
DELAY
MOV AL,AH
OUT 81h,AL ; registro de página del DMA
MOV AL,CL
DELAY
OUT 5,AL
MOV AL,CH
DELAY
OUT 5,AL ; enviada cuenta de bytes
STI
MOV AL,2
DELAY
OUT 0Ah,AL ; habilitar canal 2 de DMA
POP AX
RET
prepara_DMA ENDP
; ------------ Recibir byte del FDC en AL. A la vuelta, CF=1 si
; la operación fracasó (el FDC no estaba listo) y
; se indica la condición de timeout en «status».
fdc_read PROC
CMP CS:pcxt,ON
JE fdc_read_xt
XPUSH <CX, DX, AX>
CALL fdc_respiro ; no abrasar el FDC
MOV DX,FD_STATUS ; registro de estado del FDC
MOV CX,133 ; constante para 0,002 segundos
espera_rd: DELAY
IN AL,DX
AND AL,11000000b
CMP AL,11000000b ; ¿dato listo?
JE fdc_rd_ok
DELAY
IN AL,61h
AND AL,10h
CMP AL,AH
JE espera_rd ; reintentarlo durante 15,09 µs
MOV AH,AL
LOOP espera_rd
XPOP <AX, DX, CX>
OR status,80h ; timeout
MOV AL,0
STC ; fallo
RET
fdc_rd_ok: POP AX
INC DX ; apuntar al registro de datos
DELAY
IN AL,DX ; leer byte del FDC
XPOP <DX, CX>
CLC ; Ok
RET
fdc_read ENDP
fdc_read_xt PROC
XPUSH <CX, DX>
MOV DX,FD_STATUS ; registro de estado del FDC
XOR CX,CX ; evitar cuelgue total si falla
espera_rd_xt: IN AL,DX ; leer registro de estado
TEST AL,80h ; ¿bit 7 inactivo?
LOOPZ espera_rd_xt ; así es: el FDC está ocupado
JCXZ fdc_rd_nok_xt
INC DX ; apuntar al registro de datos
IN AL,DX ; leer byte del FDC
CLC
XPOP <DX, CX>
RET
fdc_rd_nok_xt: OR status,80h ; timeout
STC
XPOP <DX, CX>
RET
fdc_read_xt ENDP
; ------------ Enviar byte AL al FDC. A la vuelta, CF=1 si
; la operación fracasó (el FDC no estaba listo) y
; se indica la condición de timeout en «status».
fdc_write PROC
CMP CS:pcxt,ON
JE fdc_write_xt
XPUSH <CX, DX, AX>
CALL fdc_respiro ; no abrasar el FDC
MOV DX,FD_STATUS ; registro de estado del FDC
MOV CX,133 ; constante para 0,002 segundos
espera_wr: DELAY
IN AL,DX
TEST AL,80h ; ¿listo para E/S?
JNZ fdc_wr_ok
DELAY
IN AL,61h
AND AL,10h
CMP AL,AH
JE espera_wr ; reintentarlo durante 15,09 µs
MOV AH,AL
LOOP espera_wr
XPOP <AX, DX, CX>
OR status,80h ; timeout
STC ; fallo
RET
fdc_wr_ok: INC DX ; apuntar al registro de datos
POP AX
DELAY
OUT DX,AL ; enviar byte al FDC
XPOP <DX, CX>
CLC ; Ok
RET
fdc_write ENDP
fdc_write_xt PROC
XPUSH <AX, CX, DX>
MOV DX,FD_STATUS ; registro de estado del FDC
XCHG AH,AL ; preservar AL en AH
XOR CX,CX ; evitar cuelgue total si falla
espera_wr_xt: IN AL,DX ; leer registro de estado
TEST AL,80h ; ¿bit 7 inactivo?
LOOPZ espera_wr_xt ; así es: el FDC está ocupado
JCXZ fdc_wr_nok_xt
XCHG AH,AL ; recuperar el dato de AL
INC DX ; apuntar al registro de datos
OUT DX,AL ; enviar byte al FDC
XPOP <DX, CX, AX>
CLC
RET
fdc_wr_nok_xt: OR status,80h ; timeout
XPOP <DX, CX, AX>
STC
RET
fdc_write_xt ENDP
; ------------ Retardo de 60 µs para dar tiempo al FDC en 486 rápidos.
fdc_respiro PROC
CMP CS:pcxt,ON
JNE fdc_resp_at
PUSH CX
MOV CX,50
respiro: LOOP respiro ; retardo en PC/XT
POP CX
RET
fdc_resp_at: XPUSH <AX, CX>
MOV CX,4
fdc_ret: PMICRO
LOOP fdc_ret
XPOP <CX, AX>
RET
fdc_respiro ENDP
; ------------ Esperar exactamente AX milisegundos.
retardo PROC
PUSHF
XPUSHA
CMP CS:pcxt,ON
JE retardo_xt
MOV DX,16970 ; 16970 = 1193180/18*256/1000
MUL DX
MOV CL,AH ; dividir DX:AX entre 256 y
MOV CH,DL ; dejar el resultado en DX:CX
MOV DL,DH
MOV DH,0 ; DX:CX 15,09 µs-avos
retardando: PMICRO
LOOP retardando
AND DX,DX
JZ retardado
DEC DX
JMP retardando
retardado: XPOPA
POPF
RET
retardo_xt: CMP AX,54 ; como máximo 54 ms cada vez
JBE retarda_fin
PUSH AX
MOV AX,54
CALL rt_ax
POP AX
SUB AX,54
JMP retardo_xt
retarda_fin: CALL rt_ax
JMP retardado
rt_ax: MOV DX,1000 ; retardo de hasta 54 ms
MUL DX
MUL CS:tbase
MOV CX,54925
DIV CX ; AX = contador iteraciones
MOV CX,AX
EVEN ; forzar alineamiento
retarda: DEC CX
JMP SHORT $+2
JNZ retarda
RET
retardo ENDP
EVEN
ini_buffer EQU $ ; comienzo del buffer E/S
fin_residente EQU $ ; fin del área residente sin contar el buffer
bytes_resid EQU fin_residente-ini_residente
; ****************************************************************
; * *
; * I N S T A L A C I O N D E S D E E L C O N F I G *
; * *
; ****************************************************************
init PROC
LEA DX,retorno_ok
MOV CS:p_rutinas,DX ; anular 'init'
LES BP,[BX].bpb_cmd ; apuntar a los parámetros
LEA AX,bpb_ptrs
MOV [BX].bpb_cmd_desp,AX
MOV [BX].bpb_cmd_segm,CS ; tabla punteros a BPB's
XPUSH <DS, BX>
PUSH CS
POP DS ; DS: -> _PRINCIPAL
MOV BX,BP
CALL salta_nombre
LEA BP,parametros
CALL obtener_param
CALL testAT
JC init_m1 ; en PC/XT, siempre DMA
CMP param_nodma,OFF
JE init_m1
MOV modoDMA,OFF ; en AT, permitir NO-DMA
init_m1: CALL inic_general
CMP param_b,ON
JNE init_m2
MOV AX,tpista ; /B permite modificar el
MOV tbuffer,AX ; tamaño del buffer
init_m2: CALL inic_ioctl
MOV AL,num_discos
XPOP <BX, DS>
MOV [BX].num_disc_init,AL
MOV AH,[BX].nuevo_disco ; unidad en DOS 3.0+
XPUSH <CS, CS>
XPOP <DS, ES> ; DS y ES: -> _PRINCIPAL
TEST error,0FFFFh
JZ cont_instala1
JMP salida_error
cont_instala1: MOV unidad_base,AH
CALL genera_nombre ; de AL unidades desde AH
CALL analiza_equipo ; ¿ordenador adecuado?
TEST error,0FFFFh
JZ cont_instala2
JMP salida_error
cont_instala2: CMP instalado,ON
JNE cont_instala3
OR error,YAINST
JMP salida_error
cont_instala3: CALL mx_get_handle ; obtener código Multiplex
JNC handle_ok
OR error,MX64FULL ; no quedan entradas
JMP salida_error
handle_ok: MOV multiplex_id,AH ; entrada multiplex
CALL preservar_ints ; tomar nota de vectores
LEA BX,ini_buffer+15
MOV CL,4
SHR BX,CL
MOV AX,CS
ADD AX,BX
MOV sbuffer,AX
MOV sbuf512,AX
CMP param_nodma,ON
JNE usar_dma ; DMA usado
CMP param_ems,ON
JNE init_tsr
CALL alloc_EMS ; poner buffer en EMS
JMP init_tsr
usar_dma: MOV BX,tbuffer
CALL getdmaok
AND BX,BX
JZ dmaguay ; no hay problemas de DMA
MOV sbuffer,AX ; arreglar cruce frontera
MOV sbuf512,AX
ADD tbuffer,BX
OR error,DMACRUCE ; ¡maldita frontera!
dmaguay: CALL vds_dma_ok?
MOV emmtipo,BX ; tipo de EMM
JNC init_tsr
OR error,DMAPOCO ; poco buffer DMA en EMM
init_tsr: CALL inicializa_id
MOV DI,100h ; ORG 0 (compensar COM)
CALL activar_ints ; interceptar vectores
LEA DX,programa_txt ; mensaje de instalación
CALL print
LEA DX,instalado_txt
CALL print
CMP pcxt,ON
JNE ins_at
CMP param_nodma,OFF
JE ins_at
LEA DX,errxtdma_txt ; PC/XT necesita DMA
CALL print
ins_at: TEST error,DMACRUCE
JZ buffernormal
LEA DX,dma_front_txt
CALL print ; aviso de frontera DMA
buffernormal: TEST error,DMAPOCO
JZ bastantedma
LEA DX,dma_poco_txt
CALL print ; aviso de poco buffer DMA
CMP emmtipo,"QE"
LEA DX,crlf_txt
JNE pr_emm
LEA DX,emm_qemm_txt
pr_emm: CALL print ; informar de QEMM
bastantedma: CMP param_ems,ON
JNE ems_ok
CMP ems_handle,0
JNE ems_ok
LEA DX,erremsins_txt
CMP param_nodma,ON
JE err_ems_ok
LEA DX,erremsdma_txt
err_ems_ok: CALL print
ems_ok: MOV AX,longitud_total
MOV CL,4
SHL AX,CL
LDS BX,CS:pcab_peticion
MOV [BX].fin_resid_desp,AX
MOV [BX].fin_resid_segm,CS
MOV AX,100h ; instalación Ok.
RET
salida_error: LEA DX,programa_txt
CALL print
LEA DX,mal_dos_txt ; errores posibles
TEST error,MALDOS ; desde el CONFIG
JNZ prn_error
LEA DX,mal_bios_txt
TEST error,MALBIOS
JNZ prn_error
LEA DX,mal_drv_txt
TEST error,MALDRV
JNZ prn_error
LEA DX,err_sintax_txt
TEST error,ERRSINTAX ; ¿error de sintaxis?
JNZ prn_error
LEA DX,nocabe_txt
TEST error,MX64FULL
JNZ prn_error
LEA DX,ya_ins_txt
prn_error: CALL print ; imprimir error
LDS BX,CS:pcab_peticion
MOV [BX].fin_resid_desp,0 ; OFFSET 0 indica que no
MOV [BX].fin_resid_segm,CS ; quedará instalado
MOV AX,100h ; indicar retorno correcto
RET
init ENDP
; ********************************************************************
; * *
; * C O D I G O E J E C U T A D O D E S D E E L D O S *
; * *
; ********************************************************************
main PROC FAR
MOV BX,_PILA
SUB BX,_PRINCIPAL ; tamaño de este programa
ADD BX,tampila/16+17 ; más pila y más PSP
MOV AH,4Ah ; cambiar memoria asignada
INT 21h
MOV AX,_PRINCIPAL ; programa de un segmento
MOV DS,AX ; DS: -> _PRINCIPAL
LEA BP,parametros
MOV BX,81h
MOV psp,ES ; anotar PSP
CALL obtener_param ; procesar parámetros
PUSH DS
POP ES ; ES: -> _PRINCIPAL
JNC test_pmts
JMP informar ; error/ayuda
test_pmts: CMP param_nodma,ON
JNE cont_ins
CMP param_test,ON
JE cont_ins
pmt_config: OR error,PARAMCONFIG ; parámetro del CONFIG.SYS
JMP informar
cont_ins: CMP param_ems,ON
JE pmt_config
CALL null_param?
JNE proceder
CALL analiza_equipo
CMP instalado,ON
JNE ayudar ; no instalado y sin parámetros
CALL adaptar_param ; parámetros en copia residente
CALL informe ; informe de unidades/opciones
JMP fin
ayudar: MOV param_ayuda,ON
JMP informar ; no indicados parámetros
proceder: CALL inic_general
CALL analiza_equipo
TEST error,0FFFFh XOR MALDRV
JNZ informar ; error != MALDRV
CALL adaptar_param ; parámetros en copia residente
CMP param_test,ON
JE testear
CMP instalado,ON
JE ya_reside
OR error,NOINST ; programa no instalado
JMP informar ; (obligarlo para formatear)
ya_reside: CALL setbuffer
JC informar
MOV AL,maxpistas
CMP frontera,AL
JBE fr_ok
MOV frontera,AL ; limitar alcance frontera
fr_ok: CALL format_disk
JMP fin
testear: CALL setbuffer
JC informar
CALL test_disk ; calcular mayor capacidad
JMP fin
informar: CALL info
MOV AX,error
fin: MOV AH,4Ch
INT 21h ; final
main ENDP
;*********************************************************
;* *
;* SUBRUTINAS DE PROPOSITO GENERAL PARA LA INSTALACION *
;* *
;*********************************************************
INCLUDE 2MUTIL.INC
; ------------ Saltar nombre del driver en línea de órdenes del CONFIG
salta_nombre PROC
MOV AL,ES:[BX]
INC BX
CMP AL,' '
JE fin_nombre
CMP AL,9
JE fin_nombre
CMP AL,0Dh
JE fin_nombre
CMP AL,0Ah
JE fin_nombre
AND AL,AL
JZ fin_nombre
JMP salta_nombre
fin_nombre: RET
salta_nombre ENDP
; ------------ Nombrar las unidades (AL) a partir de la número AH.
genera_nombre PROC
MOV CL,AL
MOV CH,0 ; CX = nº unidades
MOV AL,AH
ADD AL,'A'
MOV AH,':'
LEA SI,tabla_letras1
LEA DI,tabla_letras2
init_nombres: MOV [SI],AX
MOV [DI],AX
ADD SI,3
ADD DI,3
INC AL
LOOP init_nombres
RET
genera_nombre ENDP
; ------------ Inicializar ciertas variables.
inic_general PROC
CALL testDRDOS
CALL testAT
JNC skip_tmtest ; en AT no calcularlo [*]
CALL cte_tiempos
MOV tbase,AX ; cte. retardo para 1/18,2 seg.
skip_tmtest:
MOV num_discos,0
MOV DL,0
CALL tipo_disco
JNC hay_unidad
MOV DL,1
CALL tipo_disco
JNC hay_unidad
OR error,MALBIOS ; no hay disqueteras
RET
hay_unidad: MOV disco,0
MOV DL,disco
CALL tipo_disco
CMP BL,2
JE tipoE_HD
CMP BL,4
JAE tipoE_HD ; hallada A: de alta densidad
INC disco
MOV DL,disco
CALL tipo_disco
CMP BL,2
JE tipoE_HD
CMP BL,4
JAE tipoE_HD ; hallada B: de alta densidad
OR error,MALDRV
RET
tipoE_HD: MOV info_E.tipo_drv,BL ; guardar tipo unidad
MOV AL,disco
MOV info_E.unidad,AL ; y si es la A: ó B:
ADD info_E.ioctl_id,AL
INC num_discos ; de momento, 1 unidad
CMP AL,1
JE fin_inic ; procesadas A: y B:
MOV DL,1
CALL tipo_disco
CMP BL,2
JE tipoF_HD
CMP BL,4
JB fin_inic ; hallada B: de alta densidad
tipoF_HD: MOV info_F.tipo_drv,BL ; guardar tipo unidad
MOV info_F.unidad,1 ; y que es la B:
ADD info_F.ioctl_id,1
INC num_discos ; 2 unidades controladas
fin_inic: MOV AX,m_35_ed ; buffer para 2.88M
CMP info_E.tipo_drv,5
JAE inic_buff
CMP info_F.tipo_drv,5
JAE inic_buff
MOV AX,m_35_hd ; buffer para 1.44M
CMP info_E.tipo_drv,4
JE inic_buff
CMP info_F.tipo_drv,4
JE inic_buff
MOV AX,m_525_hd ; buffer para 1.2M
inic_buff: MOV tbuffer,AX
RET
inic_general ENDP
; --- Comprobar si es DR-DOS 6.0 ó Novell DOS 7.0
testDRDOS PROC
MOV AX,4452h
INT 21h
JC drdos_tst
CMP AL,67h
JB drdos_tst
MOV drdos6,ON ; DR-DOS 6 / Novell DOS 7
drdos_tst: RET
testDRDOS ENDP
; ------------ Inicializar la información IOCTL de las unidades.
; Se asume que sólo DS apunta a los datos.
inic_ioctl PROC
PUSH ES ; *
PUSH DS
POP ES
LEA DI,info_E
CALL inic_ioct_DI
LEA DI,info_F
CALL inic_ioct_DI
POP ES ; *
RET
inic_ioct_DI: MOV AL,[DI].tipo_drv
LEA SI,info_drv288
CMP AL,5
JAE info_drv_ok
LEA SI,info_drv120
CMP AL,2
JE info_drv_ok
LEA SI,info_drv144
info_drv_ok: MOV CX,6
CLD
REP MOVSB
INC SI ; respetar byte tipo soporte
INC DI
MOV CX,31
REP MOVSB
RET
inic_ioctl ENDP
; ------------ Comprobar que la configuración es la adecuada.
analiza_equipo PROC
CALL residente?
MOV AL,OFF
JC set_resid
MOV AL,ON
set_resid: MOV instalado,AL
MOV AH,30h
INT 21h
XCHG AH,AL
CMP AX,31Eh ; ¿DOS 3.30 o superior?
MOV AX,MALDOS
JB pc_nok
CALL testAT
MOV pcxt,OFF
JNC pc_ok
MOV pcxt,ON
JMP pc_ok
pc_nok: OR error,AX
pc_ok: RET
analiza_equipo ENDP
; ----- Detectar 286 ó superior.
testAT PROC
PUSHF
POP AX
OR AH,70h ; intentar activar bit 12, 13 ó 14
PUSH AX ; del registro de estado
POPF
PUSHF
POP AX
AND AH,0F0h
CMP AH,0F0h
JE testedAT
STC
testedAT: CMC ; CF = 0 en AT y 1 en PC/XT
RET
testAT ENDP
; ------------ Comprobar si es un 386+
es386? PROC
PUSHF
POP AX
OR AH,70h ; intentar activar bit 12, 13 ó 14
PUSH AX ; del registro de estado
POPF
PUSHF
POP AX
AND AH,0F0h
CMP AH,0F0h
MOV AL,0
JE fin_test_CPU ; es 8086 o similar
AND AH,70h ; 286 pone bits 12, 13 y 14 a cero
JZ fin_test_CPU ; es 286
MOV AL,1 ; 386 o superior
fin_test_CPU: MOV AH,0
CMP AX,1
RET
es386? ENDP
; ------------ Calcular la constante de retardo básica para perder
; exactamente 54,925 ms. Con una regla de 3 se podrá
; después aplicar para hacer retardos de milisegundos
; en los PC/XT.
cte_tiempos PROC
XPUSH <DS, ES, BX, CX, DX>
MOV AX,3508h
INT 21h
XPUSH <ES, BX> ; preservar vector de INT 8
PUSH DS
MOV AX,40h
MOV DS,AX
MOV AL,DS:[6Ch]
espera_i8: CMP AL,DS:[6Ch]
JE espera_i8 ; esperar INT 8 ... para que no
POP DS
LEA DX,i8_crono ; venga otra en un buen rato...
MOV AX,2508h
INT 21h ; nueva rutina de INT 8
IN AL,21h
PUSH AX ; preservar estado de IRQ's
MOV AL,11111110b
OUT 21h,AL ; permitir sólo IRQ0
MOV AH,0 ; fase
MOV CX,0 ; contador
MOV BX,CX ; seguiría a 0 si fallara
EVEN ; forzar alineamiento
cuenta_iter: DEC CX ; <─┐ bucle básico de retardo
JMP SHORT $+2 ; │
JNZ cuenta_iter ; <─┘ lo interrumpirá INT 8
POP AX ; anterior estado de IRQ's
OUT 21h,AL
XPOP <DX, DS>
PUSH BX ; valor real contado
MOV AX,2508h ; restaurar vector de INT 8
INT 21h
POP AX ; (65536-AX) vueltas en 54,9 ms
NEG AX ; constante de retardo básica
XPOP <DX, CX, BX, ES, DS>
RET
i8_crono: INC AH ; nueva INT 8 que interrumpe
CMP AH,1 ; el bucle de retardo
JE fase1
CMP AH,2
JE fase2
i8_exit: MOV AL,20h
OUT 20h,AL
IRET
fase1: MOV CX,0 ; sincronizar con el reloj
JMP i8_exit
fase2: MOV BX,CX ; anotar constante de retardo
MOV CX,1 ; forzar fin del bucle
JMP i8_exit
cte_tiempos ENDP
; ------------ Inicializar área «program_id» del programa residente.
inicializa_id PROC
MOV segmento_real,CS ; anotar segmento del bloque
MOV offset_real,0 ; ídem con el offset
MOV AX,bytes_resid ; tamaño área residente
ADD AX,tbuffer ; tamaño buffer residente
ADD AX,31 ; redondeo (programa+buffer)
CMP ems_handle,0
JE mem_AX
MOV AX,bytes_resid ; tamaño área residente
ADD AX,512+SYSBYTES+GAPDEF+31 ; minibuffer+redondeo
mem_AX: MOV CL,4
SHR AX,CL
MOV longitud_total,AX
OR info_extra,3 ; SYS en formato EXE
RET
inicializa_id ENDP
; ------------ Ubicar el buffer interno en EMS.
alloc_EMS PROC
PUSH ES
MOV AX,3567h
INT 21h ; vector de INT 67h en ES:BX
MOV DI,10
LEA SI,emm_id
MOV CX,8
CLD
REP CMPSB ; ¿instalado controlador EMS?
POP ES
JE hay_emm
JMP finprep_emm
hay_emm: MOV CX,8000h ; nº de intentos prudente
emm_llama: MOV AH,40h
INT 67h
AND AH,AH
JZ emm_responde
CMP AH,82h
LOOPE emm_llama
JMP finprep_emm ; no funciona ¿?
emm_responde: MOV AH,41h
INT 67h
AND AH,AH
JZ emm_pag_ok
CMP AH,82h
JE emm_responde ; reintentar (EMM ocupado)
JMP finprep_emm
emm_pag_ok: MOV marco_ems,BX ; inicializar marco EMS
MOV AH,46h
INT 67h ; obtener versión del EMM
CMP AL,40h
JB emm_obt_kb ; versión anterior a la 4.0
MOV ems4,ON
emm_obt_pag: XPUSH <ES,DS>
POP ES
MOV AX,5800h ; obtener dirección de páginas
LEA DI,buffer_aux
INT 67h
POP ES
AND AH,AH
JZ emm_pags_ok
CMP AH,82h
JE emm_obt_pag
JMP finprep_emm
emm_pags_ok: LEA SI,buffer_aux
CLD
emm_otra_pag: LODSW
MOV BX,AX ; BX = segmento de la página
LODSW ; AX = nº de la página
AND AX,AX
JE hallada_pag0 ; encontrada página 0
LOOP emm_otra_pag
JMP finprep_emm
hallada_pag0: LODSW ; segmento página 1
SUB AX,BX
CMP AX,1024 ; ¿(pag1 - pag0) != 1024?
JNE finprep_emm ; páginas no contiguas
LODSW
LODSW ; segmento página 2
SUB AX,BX
CMP AX,2048 ; ¿(pag2 - pag0) != 2048?
JNE finprep_emm ; páginas no contiguas
LODSW
LODSW ; segmento página 3
SUB AX,BX
CMP AX,3072 ; ¿(pag3 - pag0) != 3072?
JNE finprep_emm ; páginas no contiguas
emm_obt_kb: MOV BX,tbuffer
ADD BX,16383 ; BXi = redondeo
ROL BX,1
ROL BX,1
AND BX,3 ; BX = BXi / 16384
MOV AH,43h
INT 67h
AND AH,AH
JZ ems_alloc_ok
CMP AH,82h
JE emm_obt_kb ; reintentar (EMM ocupado)
JMP finprep_emm
ems_alloc_ok: MOV ems_handle,DX
CMP ems4,ON
JNE finprep_emm
MOV AX,5301h
LEA SI,emm_nombre
INT 67h
finprep_emm: RET
alloc_ems ENDP
; ------------ Devolver ZF=1 si no se indica ningún parámetro.
null_param? PROC
MOV AH,param_ayuda
OR AH,param_dd
OR AH,param_dh
OR AH,param_ed
OR AH,param_k
OR AH,param_n
OR AH,param_test
OR AH,param_t
OR AH,param_r
OR AH,param_s
OR AH,param_f
OR AH,param_b
OR AH,param_x
OR AH,param_y
OR AH,param_m
NOT AH
MOV AL,disquetera
XOR AX,ptr_label
XOR AX,ptr_ilabel
CMP AX,-1
RET
null_param? ENDP
; ------------ Informar al usuario.
info PROC
CMP param_ayuda,ON ; ¿solicitud de ayuda?
JNE info_normal
LEA DX,ayuda_txt
CALL print
JNC fin_info
LEA DX,limpia_txt ; se pulsó ESC en la ayuda
CALL print
JMP fin_info
info_normal: LEA DX,programa_txt
CALL print
LEA DX,mal_dos_txt
TEST error,MALDOS ; ¿DOS incorrecto?
JZ otroerr2
CALL print
otroerr2: LEA DX,mal_bios_txt
TEST error,MALBIOS ; ¿BIOS obsoleta?
JZ otroerr3
CALL print
otroerr3: LEA DX,err_sintax_txt
TEST error,ERRSINTAX ; ¿error de sintaxis?
JZ otroerr4
CALL print
LEA DX,pet_ayuda_txt
CALL print
otroerr4: LEA DX,no_ins_txt
TEST error,NOINST ; ¿no instalado en CONFIG?
JZ otroerr5
CALL print
otroerr5: LEA DX,err_mem_txt
TEST error,POCAMEM ; ¿poca memoria?
JZ otroerr6
CALL print
otroerr6: LEA DX,pconfig_txt
TEST error,PARAMCONFIG ; ¿parámetro del CONFIG?
JZ fin_info
CALL print
fin_info: RET
info ENDP
; ------------ Establecer el buffer que no cruce con el DMA.
setbuffer PROC
MOV AH,48h
MOV BX,MPISTA*2/16
INT 21h
JNC haymem
OR error,POCAMEM
STC
RET
haymem: MOV BX,MPISTA ; mayor buffer posible
CALL getdmaok ; AX = segmento no conflictivo
MOV sbuffer,AX
MOV sbuf512,AX
CLC
RET
setbuffer ENDP
; ------------ Obtener un segmento no conflictivo con el DMA. A la
; entrada, AX=segmento propuesto y BX=tamaño buffer en
; bytes. A la salida, AX podría haber sido incrementado
; y BX indicaría en cuántos bytes.
getdmaok PROC
XPUSH <CX, DX>
SHR BX,1
SHR BX,1
SHR BX,1
SHR BX,1 ; bytes tamaño -> párrafos
MOV CX,AX
MOV DX,BX
ADD DX,AX ; DX = segmento final
AND DH,0F0h ; página del segmento final
AND CH,0F0h ; página del segmento inicial
MOV BX,0 ; supuesto ajuste nulo
CMP CH,DH
JE buff_ok ; no hay problemas con DMA
MOV DL,0 ; DX = nuevo segmento
MOV BX,DX
SUB BX,AX ; incremento relativo
MOV AX,DX
buff_ok: MOV CL,4
SHL BX,CL ; incremento relativo en bytes
XPOP <DX, CX>
RET
getdmaok ENDP
; ------------ Comprobar si el buffer para el DMA es suficiente, en
; caso de haber un controlador de memoria. Se devuelve
; el código de identificación del controlador en BX, o
; un valor 1234h si no hay controlador; DI indica el
; tamaño de buffer soportado y CF=1 si no basta.
vds_dma_ok? PROC
XPUSH <AX, CX, DX, SI>
CALL es386?
JNE vds_pse ; por si las moscas
MOV AX,354Bh
PUSH ES
INT 21h ; ES:BX -> INT 4Bh
MOV AX,ES
POP ES
OR AX,BX
JZ vds_pse ; INT 4Bh indefinida
CMP AX,0FFFFh
JNE hay_vds?
CMP BX,0FFFFh
JE vds_pse ; INT 4Bh indefinida
hay_vds?: MOV AX,8102h
XOR DX,DX
XOR SI,SI
XOR DI,DI ; SI:DI a 0 por si acaso
INT 4Bh
JC vds_pse ; si no hay VDS...
MOV AX,SI
OR AX,DI
JZ vds_pse ; no parece una VDS...
CMP SI,0
JE dma_s_ok
MOV DI,0FFFFh ; con 64K nos basta
dma_s_ok: CMP DI,tbuffer
JAE vds_ok
STC ; no basta el buffer
XPOP <SI, DX, CX, AX>
RET
vds_pse: MOV BX,1234h ; retornar sin problemas
MOV DI,0FFFFh
vds_ok: CLC ; basta ese buffer
XPOP <SI, DX, CX, AX>
RET
vds_dma_ok? ENDP
; ------------ Adaptar parámetros del programa si ya está instalado.
adaptar_param PROC
PUSH ES
CMP instalado,ON
JNE salir_adap ; aún no instalado
MOV ES,tsr_seg
CMP param_g,ON
JNE param_dr?
MOV AX,gaprw
MOV ES:gaprw,AX
param_dr?: CMP param_dron,ON
JNE param_droff?
MOV ES:drdos6,ON ; soporte DISKCOPY de DR-DOS
param_droff?: CMP param_droff,ON
JNE param_dwon?
MOV ES:drdos6,OFF
param_dwon?: CMP param_dwon,ON
JNE param_dwoff?
MOV ES:cachewr,ON ; caché escritura retardada
param_dwoff?: CMP param_dwoff,ON
JNE fin_adap
MOV ES:cachewr,OFF
fin_adap: MOV AX,tbase
MOV ES:tbase,AX ; actualizar siempre esta cte
salir_adap: POP ES
RET
adaptar_param ENDP
; ------------ Informar de las unidades empleadas y otras cuestiones.
informe PROC
PUSH ES
MOV ES,tsr_seg
MOV AL,ES:unidad_base ; primera letra unidad
MOV BL,ES:info_E.unidad
MOV BH,ES:info_E.tipo_drv ; datos A:
MOV CL,ES:info_F.unidad
MOV CH,ES:info_F.tipo_drv ; datos B:
POP ES
LEA DX,hay_2mgui_txt
CALL print
MOV nueva_u,AL
ADD nueva_u,'A'
informa_otra: MOV vieja_u,BL
ADD vieja_u,'A'
LEA DX,hay_en_txt
CALL print
LEA DX,nueva_u ; indicar nueva unidad
CALL print
MOV BL,BH
DEC BL
MOV BH,0
SHL BX,1
ADD BX,OFFSET t_drvs
MOV DX,[BX]
CALL print ; imprimir su tipo
LEA DX,hay2_txt
CALL print
LEA DX,vieja_u
CALL print ; imprimir letra física
AND CH,CH
JZ fin_informe ; no hay más unidades
MOV BX,CX
MOV CH,0
INC nueva_u
JMP informa_otra ; informar 2ª unidad
fin_informe: PUSH ES ; *
MOV ES,tsr_seg
LEA DX,gap_txt
CALL print
MOV AX,ES:gaprw
XOR DX,DX
MOV CL,3
CALL print_32 ; indicar el GAP
LEA DX,dma1_txt
CALL print
CMP ES:modoDMA,ON
JE modo_dma_ok
LEA DX,dmano_txt
CALL print
modo_dma_ok: LEA DX,dma2_txt
CALL print ; y el modo DMA
CMP ES:ems_handle,0
LEA DX,buffer_ems_txt
JE modo_ems_ok
CALL print
modo_ems_ok: LEA DX,cache_off_txt
CMP ES:cachewr,ON
JE modo_cache_ok
CALL print
modo_cache_ok: LEA DX,sopdr_on_txt
CMP ES:drdos6,ON
JNE modo_dr_ok
CALL print
modo_dr_ok: POP ES ; *
LEA DX,pet_ayuda_txt
CALL print ; ... cómo pedir ayuda ...
RET
informe ENDP
; ------------ Formatear disquete 2MGUI.
format_disk PROC
CALL get_drv ; obtener unidad física
JNC fmt_buen_drv
OR errw,MALDRV
JMP rep_fmt
fmt_buen_drv: CALL init_flp ; preparar áreas de datos
CALL init_boot ; construir sector de arranque
CALL set_fat_buffer ; buffer para la FAT
JNC fmt_buena_fat
JMP rep_fmt ; no hay memoria para la FAT
fmt_buena_fat: MOV errw,0
MOV status,0 ; borrar errores previos
CALL print_cabf ; mensaje de cabecera
CMP param_k,ON
JE format_ya ; opción /K: evitar pausa
LEA DX,pausaf_txt
CALL print
MOV AH,8
INT 21h ; pedir tecla
AND AL,AL
JNZ esa_tec
MOV AH,8
INT 21h ; tecla de doble código
esa_tec: LEA DX,limpia_txt
CALL print
CMP AL,13
JE format_ya
JMP teclaESC? ; se pulsó ESC
format_ya: STC
CALL reset_drv
MOV [SI].cilindro,0
fmt_otro_cil: MOV [SI].cabezal,0 ; empezar en pista/cabeza 0
fmt_otro_cab: MOV CX,4 ; reintentos
JMP fmt_empieza
fmt_repite: CLC
CALL reset_drv
fmt_empieza: CALL test_kb
JNC fmt_proc
JMP teclaESC?
fmt_proc: CALL print_cc ; imprimir nº cilindro/cabezal
CALL genera_infof
CALL motor_ok
CALL seek_drv
LEA DX,f_txt ; [F--]
CALL print
CALL formatea_pista
CALL test_err ; ¿error?
JNC fmt_wr?
JMP rep_fmt
fmt_wr?: JNZ fmt_wr
LOOP fmt_repite ; reintentos
JMP marca_pista ; pista defectuosa
fmt_wr: CMP [SI].cilindro,1
CMC
CALL init_buffer ; buffer a 0 en cilindro 0
LEA DX,w_txt
CALL print ; [-X-]
CALL escribe_pista
CALL fix_err ; detectar capacidad excesiva
CALL test_err ; ¿error?
JC rep_fmt
JNZ fmt_vr
LOOP fmt_repite ; reintentos
JMP marca_pista ; pista defectuosa
fmt_vr: CMP [SI].cilindro,2
JB si_verificar ; verificar siempre pistas 0-1
CMP param_n,ON
JE fmt_inc_cab ; verificación desactivada
si_verificar: CALL test_kb
JC teclaESC?
LEA DX,v_txt
CALL print ; [--V]
CALL lee_pista
CALL fix_err ; detectar capacidad excesiva
CALL test_err ; ¿error?
JC rep_fmt
JNZ fmt_inc_cab
LOOP fmt_repite
JMP marca_pista ; pista defectuosa
fmt_inc_cab: INC [SI].cabezal
CMP [SI].cabezal,1
JA fmt_inc_cil
JMP fmt_otro_cab ; a por otro cabezal...
fmt_inc_cil: INC [SI].cilindro
MOV AL,[SI].cilindro
CMP AL,2
JB fmt_lento
CMP param_q,ON
JE fin_fmt ; opción /Q
fmt_lento: CMP AL,maxpistas
JAE fin_fmt
JMP fmt_otro_cil ; a por otro cilindro ...
teclaESC?: CMP AX,1000h
JE fin_fmt ; Quickformat
OR errw,ABORTADO
JMP rep_fmt
marca_pista: CMP [SI].cilindro,0 ; ¿no puede ni con la primera?
JE rep_fmt ; mal asunto, es la del sistema
CALL marcar_fat
JMP fmt_inc_cab ; marcar esa pista y a por otra
fin_fmt: CALL init_disk
rep_fmt: CLC
CALL motor_off_cnt ; cuenta normal detención motor
CALL info_fmt
TEST errw,MALDRV OR MUCHAFAT OR ABORTADO
JNZ format_fin ; fin total del proceso
CMP param_k,ON
JE format_fin ; con /K sólo un disco
JMP format_disk ; formatear más discos
format_fin: RET
format_disk ENDP
; ------------ Comprobar si se pulsa ESC y limpiar buffer.
test_kb PROC
MOV AH,1
INT 16h
JZ no_ESC ; no quedan teclas en el buffer
MOV AH,0
INT 16h
CMP AL,27
JE si_ESC ; tecla ESC
CMP AX,1000h
JE si_ESC ; ALT-Q
JMP test_kb
si_ESC: STC
RET
no_ESC: CLC
RET
test_kb ENDP
; ------------ Si da error de unidad no preparada al escribir o al
; verificar en la primera pista y no lo dio al formatear,
; es que se pide más capacidad de la soportada.
fix_err PROC
TEST status,80h
JZ fix_err_r
CMP [SI].cilindro,0
JNE fix_err_r ; si no es cilindro 0, vale
MOV status,7Fh
fix_err_r: RET
fix_err ENDP
; ------------ Comprobar categoría del error. Los errores fatales
; provocan el final inmediato del formateo.
test_err PROC
CMP status,0
JE err_none
CMP status,3 ; ¿protegido contra escritura?
JE err_fatal
TEST status,80h ; ¿no preparada?
JNZ err_fatal
CMP SP,SP
CLC
RET ; ZF=1 y CF=0 -> error "venial"
err_none: CMP SP,0
CLC
RET ; ZF=0 y CF=0 -> sin error
err_fatal: CMP SP,SP
STC
RET ; ZF=1 y CF=1 -> error grave
test_err ENDP
; ------------ Poner el buffer de pista con valores de test. A la
; entrada, CF=0 selecciona un buffer lleno de ceros
; y CF=1 lleno de una secuencia aleatoria predecible.
init_buffer PROC
PUSH ES
XPUSH <AX, BX, CX>
MOV ES,sbuffer
MOV BX,0
JC buffer_rnd
CALL tpistaAX
MOV CX,AX
fill_pis0: MOV BYTE PTR ES:[BX],0
INC BX
LOOP fill_pis0 ; buffer a 0
JMP buff_init
buffer_rnd: CALL tpistaAX
MOV CX,AX
MOV semilla,1 ; nº aleatorios predecibles
fill_pisx: CALL rnd
MOV BYTE PTR ES:[BX],AL
INC BX
LOOP fill_pisx ; buffer con patrón aleatorio
buff_init: XPOP <CX, BX, AX>
POP ES
RET
init_buffer ENDP
; ------------ Imprimir cabecera de formateo.
print_cabf PROC
XPUSHA
LEA DX,fmtm1_txt
CALL print ; "Formateando ..."
MOV AL,[SI].infb.mfrontera
MOV AH,0
MUL [SI].infb.tpista1
MOV BX,DX
MOV CX,AX ; BX:CX bytes hasta FRONTERA
MOV AL,maxpistas
SUB AL,[SI].infb.mfrontera
MOV AH,0
MUL [SI].infb.tpista2 ; DX:AX bytes tras FRONTERA
ADD AX,CX
ADC DX,BX ; bytes totales por cara
MOV CL,maxpistas
MOV CH,0
DIV CX ; bytes por pista
XOR DX,DX
MOV CL,7+16
PUSH AX ; *
CALL print_32 ; imprimir bytes por pista
LEA DX,fmtm2_txt
CALL print
MOV DL,disquetera
ADD DL,'A'
MOV AH,2
INT 21h ; imprimir unidad
LEA DX,fmtm3_txt
CALL print
MOV DL,[SI].unidad
CALL tipo_disco ; tipo de la unidad
DEC BL
MOV BH,0
SHL BX,1
ADD BX,OFFSET t_drvs
MOV DX,[BX]
CALL print ; imprimir tipo
LEA DX,fmtm4_txt
CALL print
LEA DX,fmtm5_txt
CALL print
CALL print_dsk_tipo ; imprimir tipo del disquete
LEA DX,fmtm6_txt
CALL print
POP AX ; * bytes por pista
MOV BL,maxpistas
MOV BH,0
SHL BX,1 ; pore las dos caras
MUL BX ; DX:AX bytes en disco
MOV BX,1024
DIV BX ; AX Kbytes
XOR DX,DX
MOV CL,6+16
CALL print_32 ; imprimir Kbytes
LEA DX,fmtm7_txt
CALL print
XPOPA
RET
print_cabf ENDP
; ------------ Imprimir el tipo del disquete en uso.
print_dsk_tipo PROC
MOV DL,[SI].unidad
CALL tipo_disco ; tipo de la unidad
MOV BH,BL
CMP BL,5
JB ted_no
MOV BL,4 ; en 2.88M por defecto 1.44M
ted_no: MOV AL,param_dd
OR AL,param_dh
CMP AL,OFF
JE tdd_ok
DEC BL ; disco DD
tdd_ok: CMP param_ed,ON
JNE ted_ok
CMP BH,5
JNE ted_ok
MOV BL,5 ; disco 2.88M
ted_ok: DEC BL
MOV BH,0
SHL BX,1
ADD BX,OFFSET t_drvs
MOV DX,[BX]
CALL print ; imprimir tipo
RET
print_dsk_tipo ENDP
; ------------ Imprimir nº cilindro y cabezal.
print_cc PROC
XPUSHA
LEA DX,cil_txt
CALL print
MOV AL,[SI].cilindro
CALL print_8
LEA DX,cab_txt
CALL print
MOV AL,[SI].cabezal
CALL print_8
LEA DX,p_txt
CALL print
XPOPA
RET
print_cc ENDP
; ------------ Establecer buffer para la FAT.
set_fat_buffer PROC
MOV AX,fbuffer
AND AX,AX
JNZ haymemfat ; ya había memoria asignada
MOV AX,bsectfat
MOV BX,[SI].bytes_sector
MUL BX ; sectfat * tamaño sector
MOV CL,4
SHR AX,CL ; bytes -> párrafos
MOV BX,AX
MOV AH,48h
PUSH BX
INT 21h ; pedir memoria
POP BX
JNC haymemfat
OR errw,MUCHAFAT ; no hay memoria suficiente
STC
RET
haymemfat: MOV fbuffer,AX
PUSH ES ; *
MOV ES,AX
XOR DI,DI
MOV AX,bsectfat
MUL [SI].bytes_sector ; sectores -> bytes
SHR AX,1 ; palabras
MOV CX,AX
SUB CX,2 ; saltar dos primeras palabras
MOV AL,media_id
CLD
STOSB ; byte de medios
MOV AX,0FFFFh
STOSW ; otros dos bytes
MOV AL,0
CMP tipofat,12
JE init_fat4
DEC AL
init_fat4: STOSB ; 0 (FAT12) ó 0FFh (FAT16)
XOR AX,AX
REP STOSW ; poner resto de FAT a 0
POP ES ; *
CLC
RET
set_fat_buffer ENDP
; ------------ Marcar pista defectuosa en la FAT.
marcar_fat PROC
MOV AL,[SI].cilindro
SHL AL,1
ADD AL,[SI].cabezal ; AX pistas hasta la frontera
MOV AH,0
MOV CX,0 ; CX pistas desde la frontera
MOV BL,[SI].infb.mfrontera
SHL BL,1
CMP AL,BL
JBE dispis_ok
MOV CL,AL
MOV AL,BL ; hay cruce de frontera
SUB CL,AL
dispis_ok: MUL [SI].infb.tpista1
XPUSH <DX, AX>
MOV AX,CX
MUL [SI].infb.tpista2 ; DX:AX = bytes tras frontera
XPOP <BX, CX> ; CX:BX = bytes antes frontera
ADD AX,BX
ADC DX,CX ; offset al primer byte erróneo
XPUSH <AX, DX>
MOV CX,[SI].bytes_sector
DIV CX
MOV BX,AX ; BX = primer sector erróneo
CALL tpistaAX
MOV CX,AX ; tamaño pista
XPOP <DX, AX>
ADD AX,CX
ADC DX,0
MOV CX,[SI].bytes_sector
DIV CX
AND DX,DX
JZ ultserr_ok
INC AX ; AX = último sector erróneo
ultserr_ok: SUB AX,BX
MOV CL,bscluster
MOV CH,0
ADD AX,CX
DEC AX
XOR DX,DX
DIV CX ; AX = clusters defectuosos
DEC BX ; descontar BOOT
PUSH AX
MOV AX,32
MUL brootdir
DIV [SI].bytes_sector
SUB BX,AX ; descontar ROOT
POP AX
MOV CL,bnfats
MOV CH,0
desc_fat: SUB BX,bsectfat
LOOP desc_fat ; descontar FAT(s)
XCHG AX,BX ; AX=primer sector, BX=nºclusters
XOR DX,DX
MOV CL,bscluster
DIV CX ; AX = primer cluster
ADD AX,2 ; se numeran desde 2
MOV CX,BX
marcar: CALL badpoke_fat ; marcar cluster erróneo
INC AX
LOOP marcar
RET
marcar_fat ENDP
; --- Modificar una entrada en la FAT12 ó 16.
badpoke_fat PROC
XPUSH <DS, AX, BX, CX>
MOV DS,fbuffer
XOR BX,BX
CMP CS:tipofat,16
JE poke_fat16
MOV DX,0FF7h ; cluster defectuoso
CALL poke_fat12
JMP fat_poked
poke_fat16: SHL AX,1
ADD BX,AX
MOV WORD PTR DS:[BX],0FFF7h
fat_poked: XPOP <CX, BX, AX, DS>
RET
badpoke_fat ENDP
; --- Escribir un elemento en una FAT-12
; Entrada: AX = posición de dicho elemento
; DS:BX = FAT cargada en memoria
; DX = nuevo valor de dicho elemento
poke_fat12 PROC
PUSH AX ; preservar registros
PUSH BX
PUSH DX
ADD BX,AX ; BX = BX + cluster
SHR AX,1 ; AX = cluster / 2
PUSHF ; CF = 1 si impar
ADD BX,AX ; BX = BX + cluster * 1,5
MOV AX,[BX] ; AX = palabra con dato 12 bits
POPF
JC poke_fat_imp
AND AX,1111000000000000b ; preservar la otra entrada
JMP poke_fat_ok
poke_fat_imp: AND AX,0000000000001111b ; preservar la otra entrada
PUSH CX
MOV CL,4
SHL DX,CL ; colocarlo: 4 bits a la izda
POP CX
poke_fat_ok: OR AX,DX ; «mezclar»
MOV [BX],AX ; nuevo valor en la FAT
POP DX
POP BX
POP AX
RET ; retorno sin alterar registros
poke_fat12 ENDP
; ------------ Inicializar BOOT y FAT (y ROOT si procede).
init_disk PROC
XPUSHA
MOV [SI].cilindro,0
MOV [SI].cabezal,0
CLC
CALL init_buffer ; buffer a 0
MOV CX,[SI].bytes_sector
XPUSH <ES, SI> ; *
MOV ES,sbuffer
XOR DI,DI
LEA SI,sector_boot
CLD
REP MOVSB ; crear BOOT
XPOP <SI, ES> ; *
CLC
CALL reset_drv
CALL motor_ok
CALL seek_drv
CALL escribe_pista ; grabar a bajo nivel el BOOT
CMP status,0
JNE fallo_init
PUSH ES
MOV ES,tsr_seg
MOV ES:[SI].cambiodisco,ON ; simular cambio de disco
POP ES
MOV DL,disquetera
INC DL
MOV AH,32h
PUSH DS
INT 21h ; forzar acceso a disco usando
POP DS ; ya el sistema operativo
MOV AL,disquetera
XOR BX,BX
MOV CX,bsectfat ; sectores en FAT
MOV DX,1
PUSH DS ; *
MOV DS,fbuffer
CALL int26h ; grabar FAT1
POP DS ; *
JC fallo_init ; fallo al escribir FAT
CMP bnfats,1
JE init_root ; sólo una FAT (CF=0)
XOR BX,BX
MOV CX,bsectfat
MOV DX,CX
INC DX ; saltar FAT1 + BOOT
MOV AL,disquetera
PUSH DS ; *
MOV DS,fbuffer
CALL int26h ; grabar FAT2
POP DS ; *
JNC init_root
fallo_init: OR errw,MALSYS ; fallo en áreas del sistema
JMP fin_init
init_root: MOV BX,ptr_label
AND BX,BX
JNZ tetiq_ok
MOV BX,ptr_ilabel
AND BX,BX
JZ fin_init ; no hay etiqueta de volúmen
tetiq_ok: CLC
CALL init_buffer ; buffer a 0
CALL copia_etiq
CMP BX,ptr_ilabel
JNE wr_root
CALL inc_etiq
wr_root: MOV CX,bsectfat
MOV AL,bnfats
MOV AH,0
MUL CX
INC AX ; primer sector directorio raíz
MOV DX,AX
MOV CX,1
MOV AL,disquetera
PUSH DS ; *
MOV DS,sbuffer
XOR BX,BX
CALL int26h ; grabar ROOT
POP DS
fin_init: XPOPA
RET
init_disk ENDP
; ------------ Como el MS-DOS 7 de Windows 95 (beta 2) no deja usar
; la INT 26h, se graba por IOCTL :-)
int26h PROC
XPUSHA
PUSH ES
MOV ES,ES:tsr_seg
MOV AH,ES:drdos6
MOV ES:drdos6,OFF ; anular emulación DR-DOS
MOV SI,1 ; con caché: CX operaciones
CMP ES:cachewr,ON
MOV SI,CX ; sin caché: una operación
JE nsi26ok
nsi26ok: POP ES
i26_buc: XPUSH <AX, BX, CX, DX, SI, DS> ; * (preservar emulacion)
LEA DI,buffer_aux
MOV BYTE PTR ES:[DI],0
MOV WORD PTR ES:[DI+1],0 ; cabezal
MOV WORD PTR ES:[DI+3],DX ; primer cilindro
MOV WORD PTR ES:[DI+5],0 ; primer sector
MOV WORD PTR ES:[DI+7],SI ; nº sectores
MOV WORD PTR ES:[DI+9],BX
MOV WORD PTR ES:[DI+11],DS ; dirección
INC AX
MOV BL,AL ; unidad
MOV AX,440Dh
MOV CX,841h ; escribir pista
MOV DX,DI
PUSH ES
POP DS
INT 21h
XPOP <DS, SI, DX, CX, BX, AX> ; *
JC i26_fallo
ADD BX,ES:boot_tsect
INC DX
SUB CX,SI
JNZ i26_buc
CLC
i26_fallo: PUSH ES
MOV ES,ES:tsr_seg ; cuidado con flags :-)
MOV ES:drdos6,AH ; restaurar emulación DR-DOS
POP ES
XPOPA
RET
int26h ENDP
; --- Crear etiqueta de volúmen (psp:BX -> sbuffer:0)
copia_etiq PROC
XPUSHA
XPUSH <ES, DS>
CLD
MOV ES,sbuffer
XOR DI,DI
MOV DS,psp
MOV SI,BX
MOV CX,11
JCXZ nom_et_cp
genera_et: LODSB
CMP AL,' '
JE completa_et
CMP AL,9
JE completa_et
CMP AL,'/'
JE completa_et
CMP AL,13
JE completa_et
STOSB
LOOP genera_et
JMP nom_et_cp
completa_et: MOV AL,' '
STOSB
LOOP completa_et
nom_et_cp: MOV BYTE PTR ES:[11],28h
POP DS
MOV WORD PTR ES:[22],2048 ; 1:00
MOV WORD PTR ES:[24],7745 ; 1/2/95
LEA DX,null
MOV AX,3D00h
MOV CX,0
INT 21h ; abrir fichero "NUL"
JC fin_cpet
MOV BX,AX
MOV AX,5700h
PUSH BX
INT 21h ; consultar su fecha/hora
POP BX
JC fin_cpetcf
MOV AX,CX
OR AX,DX
JZ fin_cpetcf
MOV WORD PTR ES:[22],CX ; hora
MOV WORD PTR ES:[24],DX ; fecha
fin_cpetcf: MOV AX,3E00h
INT 21h ; cerrar fichero "NUL"
fin_cpet: POP ES
XPOPA
RET
copia_etiq ENDP
; --- Incrementar nº de etiqueta de volúmen.
inc_etiq PROC
PUSH DS
MOV DS,psp
MOV CX,16
busca_fetq: MOV AL,[BX]
CMP AL,' '
JE fin_etq
CMP AL,9
JE fin_etq
CMP AL,'/'
JE fin_etq
CMP AL,13
JE fin_etq
INC BX
LOOP busca_fetq
JMP etq_inc
fin_etq: DEC BX
MOV AL,[BX]
CMP AL,'0'
JB etq_inc
CMP AL,'9'
JA etq_inc
INC AL
CMP AL,'9'
JA etq_p10
MOV [BX],AL
JMP etq_inc
etq_p10: MOV BYTE PTR [BX],'0'
JMP fin_etq
etq_inc: POP DS
RET
inc_etiq ENDP
; ------------ Inicializar sector de arranque.
init_boot PROC
MOV AL,[SI].infb.vunidad2
MOV bootp.vunidad2,AL
MOV AH,frontera ; disco dividido en dos mitades
CMP AL,[SI].vunidad1
JNE init_fr
MOV AH,maxpistas ; disco uniforme
init_fr: MOV bootp.mfrontera,AH
MOV [SI].infb.mfrontera,AH
MOV AX,bsectini
MOV boot_tsect,AX ; tamaño de sector usado
MOV AX,tcluster
XOR DX,DX
DIV boot_tsect
AND AL,AL
JNZ init_sc
INC AL
init_sc: MOV bscluster,AL ; sectores por cluster
MOV AL,nfats
MOV bnfats,AL ; número de FATs
MOV AX,32
MUL rootdir
DIV boot_tsect
AND DX,DX
JZ bdir_ok
INC AX
bdir_ok: MOV srootdir,AX ; entradas raíz llenando sectores
MUL boot_tsect
MOV CX,32
DIV CX
MOV brootdir,AX ; nº entradas ajustado
MOV AX,[SI].infb.tpista2
MOV bootp.tpista2,AX
MOV AX,[SI].infb.tpista1
MOV bootp.tpista1,AX
MOV BL,bootp.mfrontera
MOV BH,0
SHL BX,1
MUL BX
MOV CX,DX
MOV BX,AX ; CX:BX bytes primera parte disco
MOV AL,maxpistas
SUB AL,[SI].infb.mfrontera
MOV AH,0
SHL AX,1
MUL bootp.tpista2 ; DX:AX bytes segunda parte disco
ADD AX,BX
ADC DX,CX ; DX:AX bytes totales en el disco
DIV boot_tsect
MOV bsectores,AX ; AX = número de sectores
DEC AX ; calcular FAT...
SUB AX,srootdir ; AX = sect tot - 1 boot - N raíz
MOV CX,AX
MOV AL,bscluster
MOV AH,0
SHL AX,1
MUL boot_tsect ; bytes_sect * sect_cluster * 2
MOV BX,3 ; 1.5 * 2 = 3 (FAT12)
DIV BX
ADD AL,bnfats
ADC AH,0
XCHG AX,CX
XOR DX,DX
DIV CX ; AX = sectores ocupados por FAT12
AND DX,DX
JZ f12_ok
INC AX
f12_ok: MOV bsectfat,AX ; sectores en FAT12
MOV tipofat,12 ; supuesta FAT-12
ADD AX,srootdir
INC AX
SUB AX,bsectores ; (fat+root+1) - sectores totales
NEG AX ; resta al revés
XOR DX,DX
MOV CL,bscluster
MOV CH,0
DIV CX ; AX = nº clusters
CMP AX,4085
JB boot_dir ; en efecto, la FAT es de 12
MOV AX,bsectores
DEC AX ; calcular FAT...
SUB AX,srootdir ; AX = sect tot - 1 boot - N raíz
MOV CX,AX
MOV AL,bscluster
MOV AH,0
SHL AX,1
MUL boot_tsect ; bytes_sect * sect_cluster * 2
MOV BX,4 ; 2 * 2 = 4 (FAT16)
DIV BX
ADD AL,bnfats
ADC AH,0
XCHG AX,CX
XOR DX,DX
DIV CX ; AX = sectores ocupados por FAT12
AND DX,DX
JZ f16_ok
INC AX
f16_ok: MOV bsectfat,AX ; sectores en FAT16
MOV tipofat,16
MOV BYTE PTR ftipo+4,'6'
boot_dir: MOV AL,bnfats
MOV AH,0
MUL bsectfat ; sectores ocupados por FATs
INC AX ; más BOOT
ADD AX,srootdir ; más ROOT
SUB AX,bsectores
NEG AX ; sectores totales - ocupados
MOV BL,bscluster
MOV BH,0
XOR DX,DX
DIV BX ; DX = sectores redundantes
MOV AX,boot_tsect
MUL DX
MOV BX,32
DIV BX
ADD brootdir,AX ; aprovecharlos para engordar ROOT
CMP brootdir,240
JBE boot_ok
MOV brootdir,240 ; pero sin pasarse
boot_ok: CALL rnd
MOV WORD PTR bserie,AX ; inicializar nº serie
CALL rnd
MOV WORD PTR bserie+2,AX
RET
init_boot ENDP
; ------------ Informe del formateo.
info_fmt PROC
CALL pr_error ; posible mensaje de error
JNC cont_info_fmt
RET
cont_info_fmt: LEA DX,capacidad1_txt
CALL print
MOV AX,bsectores
MOV CX,[SI].bytes_sector
MUL CX
MOV CL,10+16
CALL print_32 ; capacidad cruda en bytes
LEA DX,capacidad2_txt
CALL print
MOV AX,ptr_label
OR AX,ptr_ilabel
JZ no_etiq
LEA DX,etiq_txt
CALL print
MOV CX,11
XOR BX,BX
PUSH DS
MOV DS,sbuffer
pr_etq: MOV AH,2
MOV DL,[BX]
XPUSH <BX, CX>
INT 21h
XPOP <CX, BX>
INC BX
LOOP pr_etq
POP DS
LEA DX,crlf_txt
CALL print
no_etiq: MOV AX,brootdir
XOR DX,DX
MOV CL,11+16
CALL print_32 ; entradas en directorio raíz
LEA DX,if1_txt
CALL print
MOV AH,36h
MOV DL,disquetera
INC DL
INT 21h ; obtener espacio en disco
CMP AX,-1
JNE info_espacio
LEA DX,err_info_txt
CALL print
RET
info_espacio: XPUSH <AX, BX, CX, DX>
MOV AX,DX
XOR DX,DX
MOV CL,11+16
CALL print_32 ; número de clusters
LEA DX,if2_txt
CALL print
XPOP <DX, CX, BX, AX>
XPUSH <AX, BX, CX, DX>
MUL CX
MOV CL,11+16
CALL print_32 ; bytes por cluster
LEA DX,if3_txt
CALL print
XPOP <DX, CX, BX, AX>
XPUSH <AX, BX, CX, DX>
MOV BX,DX
MUL CX
MUL BX
MOV CL,11+16
CALL print_32 ; bytes totales
LEA DX,if4_txt
CALL print
XPOP <DX, CX, BX, AX>
XPUSH <AX, BX, CX, DX>
SUB DX,BX
MOV BX,DX
MUL CX
MUL BX
MOV CL,11+16
CALL print_32 ; bytes defectuosos
LEA DX,if5_txt
CALL print
XPOP <DX, CX, BX, AX>
MUL CX
MUL BX
MOV CL,11+16
CALL print_32 ; bytes libres
LEA DX,if6_txt
CALL print
RET
info_fmt ENDP
; ------------ Imprimir errores de trabajo.
pr_error PROC
LEA DX,limpia_txt
CALL print
CALL get_err_crit
TEST errw,0FFFFh
JNZ errorfmt
CLC ; no hubo error
RET
errorfmt: LEA DX,no_2mgui_txt
TEST errw,MALDRV
JZ errorfmt2?
CALL print ; la unidad no es 2MGUI
errorfmt2?: LEA DX,abortado_txt
TEST errw,ABORTADO
JZ errorfmt3?
CALL print ; formateo abortado
errorfmt3?: LEA DX,no_prep_txt
TEST errw,NOPREP
JZ errorfmt4?
CALL print ; unidad no preparada
errorfmt4?: LEA DX,err_prot_txt
TEST errw,PROTESCR
JZ errorfmt5?
CALL print ; protegida contra escritura
errorfmt5?: LEA DX,mal_dens_txt
TEST errw,MALADENS
JZ errorfmt6?
CALL print ; densidad incorrecta
errorfmt6?: LEA DX,mal_sys_txt
TEST errw,MALSYS
JZ errorfmt7?
CALL print ; fallo en áreas del sistema
errorfmt7?: LEA DX,mucha_fat_txt
TEST errw,MUCHAFAT
JZ errorfmt8?
CALL print ; FAT demasiado grande
errorfmt8?: LEA DX,mucha_pis_txt
TEST errw,MUCHAPISTA
JZ errorfmt9?
CALL print ; tamaño de pista no soportado
errorfmt9?: STC ; hubo error
RET
pr_error ENDP
; ------------ Obtener error fatal.
get_err_crit PROC
CMP status,0
JNE hay_crit?
RET
hay_crit?: MOV AX,NOPREP
TEST status,80h
JZ err2?
OR errw,AX ; unidad no preparada
RET
err2?: MOV AX,PROTESCR
CMP status,3
JNE err7f?
OR errw,AX ; protegida contra escritura
RET
err7f?: MOV AX,MUCHAPISTA
CMP status,7Fh
JNE err3
OR errw,AX ; tamaño de pista no soportado
RET
err3: OR errw,MALADENS ; otro caso: mala densidad
RET
get_err_crit ENDP
; ------------ Test de capacidad máxima soportada y velocidad de
; rotación.
test_disk PROC
CALL get_drv
CALL init_flp ; preparar áreas de datos
MOV gaprw,-1 ; rutinas E/S en modo test
MOV [SI].infb.mfrontera,86
LEA DX,test_txt1
CALL print
LEA DX,lin_txt
CALL print ; mensajes de cabecera
MOV AL,[SI].unidad
CALL drvfloppy?
JNC test_drvok
LEA DX,mal_unidad_txt
CALL print
JMP test_ret ; unidad incorrecta
test_drvok: CMP param_dh,ON
JNE test_drvAL
LEA DX,dh_test_txt
CALL print
JMP test_ret ; parámetro /DH en test
test_drvAL: CMP param_nodma,OFF
JE test_posible
CMP pcxt,OFF
JE test_posible
LEA DX,errxtdma_txt
CALL print
JMP test_ret ; PC/XT: sólo vale con DMA
test_posible: LEA DX,test_txt_t
CALL print
MOV AH,0
INT 16h ; pausa inicial
LEA DX,limpia_txt
CALL print
CMP AL,27
JNE hacer_test
test_esc: LEA DX,limpia_txt ; cancelado con ESC
CALL print
LEA DX,test_esc_txt
CALL print
JMP test_ret
hacer_test:
MOV modoDMA,ON ; supuesto con DMA
CMP param_nodma,ON
JNE haz_test
MOV modoDMA,OFF ; pues es sin él
MOV tmodo,0 ; primer test con bits iguales
haz_test: CMP modoDMA,OFF
JE aviso_sincero
CALL vds_dma_ok?
MOV AX,14*1024 ; buffer DMA para 1.44M
CMP [SI].tsector,7
JE tdok
MOV AX,28*1024 ; buffer DMA para 2.88M
tdok: CMP DI,AX
JAE otro_test
LEA DX,test_bdma_txt
CALL print
JMP otro_test
aviso_sincero: LEA DX,test_dma_txt
CALL print
otro_test: CALL test_pista
JC test_fatal ; fallo grave (protegido, etc).
CMP status,1
JNE test_prosigue ; no hay tecla ESC
LEA DX,limpia_txt ; cancelado con ESC
CALL print
LEA DX,test_esc_txt
CALL print
JMP ret_cam_test
test_prosigue: CMP status,2
JNE test_info
CALL pr_error ; mala densidad
JMP ret_cam_test
test_fatal: CALL pr_error ; imprimir error trágico
JMP ret_cam_test
test_info: LEA DX,limpia_txt
CALL print
LEA DX,test_r_txt11c ; información de resultados
CMP modoDMA,ON
JE tif1
LEA DX,test_r_txt11s
tif1: CALL print ; con/sin DMA
LEA DX,test_r_txt12
CALL print
LEA DX,test_r_txt12i
CMP tmodo,0
JE tif2
LEA DX,test_r_txt12d
tif2: CALL print ; bits idénticos/aleatorios
LEA DX,test_r_txt13
CALL print
MOV AX,bytes_ok
SUB AX,SYSBYTES
XOR DX,DX
MOV CL,6+16
CALL print_32 ; bytes soportados
LEA DX,test_r_txt14
CALL print
CMP AX,[SI].infb.tpista2
JAE pr_test_res
CMP modoDMA,OFF
JE pr_test_res ; no decir bobadas en NO-DMA
PUSH AX
MOV AX,243
MUL [SI].infb.tpista2
MOV DH,AH
XCHG DH,DL ; DX = 95% de tpista2
POP AX
CMP AX,DX
JAE info_maldrv ; diferencia modesta
LEA DX,disco_def_txt
CALL print ; ¡lo que casca es el disco!
JMP gap_bien
info_maldrv: LEA DX,test_res_mal
CALL print ; unidad pésima
pr_test_res: LEA DX,test_r_txt15
CALL print
MOV AX,bytes_max
SUB AX,bytes_ok
XOR DX,DX
MOV CL,6+16
CALL print_32 ; imprimir GAP mínimo
LEA DX,test_r_txt14
CALL print
CMP AX,GAPDEF
JBE gap_bien
CMP AX,255
JA gap_bien ; no decir bobadas si es raro
CMP modoDMA,OFF
JE gap_bien ; no decir bobadas en NO-DMA
LEA DX,aviso_gap_txt
CALL print
gap_bien: INC tmodo
CMP tmodo,1
JA no_mas_test
JMP otro_test ; test con bits aleatorios
no_mas_test: LEA DX,test_res_txt3
CALL print
CALL spin_disk ; velocidad rotación
ret_cam_test: CMP instalado,ON
JNE test_ret_cam ; programa no residente
PUSH ES
MOV ES,tsr_seg
MOV ES:[SI].controldrv,ON
MOV ES:[SI].cambiodisco,ON ; simular cambio de disco
POP ES
test_ret_cam: CMP status,3
JE test_ret ; salvo protegido de escritura...
TEST status,80h
JNZ test_ret ; o unidad no preparada...
LEA DX,disco_mal_txt
CALL print ; recordar disco dañado
test_ret: CLC
CALL motor_off_cnt ; cuenta normal detención motor
RET
test_disk ENDP
; --- Determinar la capacidad de la pista.
test_pista PROC
MOV bytes_ok,0 ; supuesto ninguno
MOV AX,tpistamax1
SHL AX,1 ; AX = tpistamax1 * 2
MOV tmax,AX
MOV CL,3
SHR AX,CL ; AX = tpistamax1 / 4
ADD tmax,AX ; máximo posible (tmax+tmin)/2
MOV tmin,0 ; mínimo posible
MOV iter,16 ; como mucho, 16 test
STC
CALL reset_drv
nuevo_test: CALL test_kb
JNC test_proc
JMP test_abortado ; se pulsó ESC
test_proc: MOV status,0
MOV [SI].cilindro,0
MOV [SI].cabezal,0
LEA DX,test_txt2
CALL print ; mensaje de "Probando..."
MOV AX,tmax
ADD AX,tmin
SHR AX,1
MOV [SI].infb.tpista1,AX ; tamaño de prueba
CMP AX,1500
JAE test_cont
JMP test_mal_dens ; aquí pasa algo raro
test_cont: CALL info_bytes
CALL motor_ok
CALL seek_drv
CALL genera_infof
CALL formatea_pista ; 1º intento formateo
CMP status,0
JE test_wr
CALL formatea_pista ; 2º intento formateo
CMP status,0
JNE fallo_test
test_wr: CMP tmodo,1
CMC ; CF==0 si tmodo==0
CALL init_buffer
CALL escribe_pista ; 1º intento escritura
CMP status,0
JE test_rd
CALL escribe_pista ; 2º intento escritura
CMP status,0
JNE fallo_test
test_rd: CMP tmodo,1 ; CF==1 si tmodo==0
CALL init_buffer
CALL lee_pista ; 1º intento lectura
CALL cnt_pista
CMP status,0
JE exito_test
CMP tmodo,1 ; CF==1 si tmodo==0
CALL init_buffer
CALL lee_pista ; 2º intento lectura
CALL cnt_pista
CMP status,0
JNE fallo_test
exito_test: MOV AX,[SI].infb.tpista1 ; funcionó...
MOV bytes_max,AX
MOV AX,tmax
ADD AX,tmin
SHR AX,1
MOV tmin,AX ; ...subir límite mínimo
JMP nuevo_test?
fallo_test: CALL test_err ; falló...
JC aborta_test ; fallo grave
MOV AX,tmax
ADD AX,tmin
SHR AX,1
MOV tmax,AX ; ...bajar límite máximo
nuevo_test?: MOV status,0 ; borrar errores anteriores
MOV AX,tmax
CMP AX,tmin
JBE exit_test
DEC iter ; contador de intentos
JZ exit_test
JMP nuevo_test
test_abortado: MOV status,1 ; indicar test abortado
JMP exit_test
test_mal_dens: MOV status,2 ; probablemente mala densidad
exit_test: CLC
RET
aborta_test: STC
RET
test_pista ENDP
; --- Comprobar qué parte de la pista se ha leído bien.
cnt_pista PROC
XPUSH <ES, AX, BX, CX>
MOV ES,sbuffer
XOR BX,BX
MOV CX,[SI].infb.tpista1
CMP tmodo,0
JE test0
MOV semilla,1 ; bits aleatorios
testx: CALL rnd ; nº "aleatorio" esperado
CMP ES:[BX],AL
JNE test_rt
INC BX
LOOP testx ; comprobar cuántos coinciden
JMP test_rt
test0: CMP BYTE PTR ES:[BX],0 ; bits idénticos
JNE test_rt
INC BX
LOOP test0 ; comprobar cuántos coinciden
test_rt: MOV AX,[SI].infb.tpista1
SHR AX,1
CMP CX,AX
JA test_mal ; ni media pista bien leída
MOV AX,[SI].infb.tpista1
SUB AX,CX
MOV bytes_ok,AX ; los que se han leído bien
MOV status,0
CLC
JMP pista_tr
test_mal: MOV status,2 ; necesaria al menos 1/2 pista
STC
pista_tr: XPOP <CX, BX, AX, ES>
RET
cnt_pista ENDP
; --- Informar de la capacidad en fase de test. A la
; entrada, AX = bytes por pista en prueba.
info_bytes PROC
XOR DX,DX
MOV CL,6+16
CALL print_32 ; capacidad en pruebas
LEA DX,test_txt3
CALL print
MOV DL,disquetera
ADD DL,'A'
MOV AH,2
INT 21h ; imprimir unidad
LEA DX,test_txt4
CALL print
CALL print_dsk_tipo ; imprimir su tipo
LEA DX,test_txt5
CALL print ; códigos de retroceso
RET
info_bytes ENDP
; --- Calcular e imprimir la velocidad de rotación.
spin_disk PROC
PUSH ES
MOV ES,sbuffer
XOR DI,DI
MOV BYTE PTR ES:[DI],1 ; 1 sector
MOV BYTE PTR ES:[DI+1],2 ; de 512 bytes
MOV BYTE PTR ES:[DI+2],0 ; cilindro 0
MOV BYTE PTR ES:[DI+3],0 ; cabezal 0
MOV BYTE PTR ES:[DI+4],0 ; sector 0
MOV BYTE PTR ES:[DI+5],2 ; 512 bytes
POP ES
CLC
CALL reset_drv
CALL motor_ok
CALL seek_drv
CALL formatea_pista ; pista de pruebas
CLC
CALL reset_drv
CALL motor_ok
CALL seek_drv
PUSH DS ; *
MOV AX,350Eh
INT 21h
XPUSH <ES, BX> ; ** preservar INT 0Eh
LEA DX,nueva_int23
MOV AX,2523h
INT 21h ; establecer nueva INT 23h
LEA DX,nueva_irq6 ; (para evitar Ctrl-Break)
MOV AX,250Eh
INT 21h ; establecer nueva INT 0Eh
IN AL,61h
AND AL,0FDh ; inhibir sonido
OR AL,1
OUT 61h,AL
MOV AL,10110100b
OUT 43h,AL ; 8254: cnt2 byte bajo/alto
MOV AL,0FFh
DELAY
OUT 42h,AL
DELAY
OUT 42h,AL ; cuenta 65535
MOV cnt_l,0FFFFh
MOV cnt_h,0
LEA DX,spin0_txt
CALL print ; cabecera
MOV iter,0 ; prueba en curso
repite_spin: CMP iter,10
JBE calc_spin ; como mínimo, 10 test
CALL test_kb
JNC calc_spin
JMP fin_spin
calc_spin: MOV AL,01001010b ; comando de lectura de ID's
CALL fdc_write
JNC spin_b1
JMP err_spin
spin_b1: MOV AL,[SI].unidad
MOV irq6,OFF ; bajar flag de interrupción
CALL fdc_write ; byte 1 de la orden
STC
CALL motor_off_cnt ; evitar que se pare el motor
CMP iter,4
JB calc_rot ; no imprimir 4 primeros test
LEA DX,spin1_txt
CALL print
PUSH SI ; *
MOV SI,dif_l
MOV DI,dif_h
MOV AX,25000
CALL mult32x16 ; resultado en DXDISI
MOV AX,29829
CALL divi48x15 ; 25000 / 29829 =
XOR DX,DX ; = (1/1193180) * 1000000
MOV AX,iter
SUB AX,3 ; nº iteraciones efectivas
CALL divi48x15
MOV DX,DI
MOV AX,SI
POP SI ; *
MOV cntms_h,DX
MOV cntms_l,AX
MOV CL,01100111b
CALL print_32 ; imprimir milisegundos
LEA DX,spin2_txt
CALL print
MOV AX,iter
XOR DX,DX
MOV CL,4
CALL print_32 ; imprimir iteraciones
LEA DX,spin3_txt
CALL print
calc_rot: MOV AX,cnt_l
MOV DX,cnt_h
MOV CX,37 ; timeout en 2 segundos
espera_irq6: CMP irq6,ON
JE llego_irq6
MOV BX,AX
MOV AL,10000100b
OUT 43h,AL ; 8254: enclavar contador 2
DELAY
IN AL,42h
XCHG AH,AL
DELAY
IN AL,42h
XCHG AH,AL ; AX = nueva cuenta
CMP AX,BX
JBE espera_irq6
INC DX
LOOP espera_irq6
JMP err_spin ; timeout
llego_irq6: CMP iter,2
JNE guarda_tm ; desechar 2 primeras pruebas
XPUSH <AX, DX>
MOV CX,65535
SUB CX,AX
MOV AX,65535
MUL DX ; DX:AX clocks del 8254
ADD AX,CX
ADC DX,0
MOV dif0_l,AX
MOV dif0_h,DX ; valor inicial
XPOP <DX, AX>
guarda_tm: MOV cnt_l,AX
MOV cnt_h,DX ; cuenta actual
MOV AX,65535
MUL DX
MOV CX,65535
SUB CX,cnt_l
ADD AX,CX
ADC DX,0 ; DX:AX clocks 8254 actuales
SUB AX,dif0_l
SBB DX,dif0_h
MOV dif_l,AX
MOV dif_h,DX ; tiempo transcurrido
LEA BX,fdc_result
MOV CX,7
sect_rd_res: CALL fdc_read ; leyendo resultados
MOV [BX],AL
INC BX
LOOP sect_rd_res
TEST fdc_result,11000000b ; ¿error?
JNZ err_spin
INC iter
CMP iter,1000
JAE fin_spin ; no más de 1000 test
JMP repite_spin
fin_spin: XPOP <DX, DS> ; **1
MOV AX,250Eh
INT 21h ; restaurar INT 0Eh
POP DS ; *1
CALL informe_spin
RET
err_spin: XPOP <DX, DS> ; **2
MOV AX,250Eh
INT 21h ; restaurar INT 0Eh
POP DS ; *2
LEA DX,spine_txt
CALL print ; indicar que hubo problemas
RET
spin_disk ENDP
; --- Nueva rutina de INT 0Eh.
nueva_irq6 PROC
PUSH AX
MOV AL,20h
OUT 20h,AL ; EOI
POP AX
MOV CS:irq6,ON ; indicar interrupción
nueva_int23: IRET
nueva_irq6 ENDP
; --- Informar sobre la calidad de la disquetera.
informe_spin PROC
LEA DX,spind_txt
CALL print
PUSH SI ; *
MOV DX,cntms_h
MOV AX,cntms_l
MOV DI,3
MOV SI,3392 ; DISI = 200000 (3½ HD)
CMP DX,3
JAE splim_ok
CMP AX,52261
JA splim_ok
MOV DI,2
MOV SI,35594 ; DISI = 166666 (5¼ HD)
splim_ok: SUB AX,SI
SBB DX,DI
JNC spsign_ok
ADD AX,SI
ADC DX,DI
XPUSH <AX, DX> ; signo '-'
MOV DL,'-'
MOV AH,2
INT 21h
XPOP <DX, AX>
XPUSH <SI, DI>
SUB SI,AX
SBB DI,DX
MOV AX,SI
MOV DX,DI ; restado el pequeño del grande
XPOP <DI, SI>
STC
spsign_ok: PUSHF ; ** preservar signo
CMP DX,0
JNE fallo_sp ; muy raro, demasiada diferencia
CMP AX,5000
JA fallo_sp ; muy raro, demasiada diferencia
MOV CL,01100101b
CALL print_32
PUSH AX ; ***
LEA DX,spinf1_txt
CALL print
MOV AX,SI
MOV DX,DI
MOV CL,01100111b
CALL print_32
LEA DX,spinf2_txt
CALL print
POP AX ; ***
POPF ; **1 signo
POP SI ; *1
LEA BX,spinf_calidad
JC busca_calidad ; unidad rápida
XOR AX,AX ; las lentas siempre buenas ;-)
busca_calidad: CMP AX,[BX]
JB dicha_calidad
CMP WORD PTR [BX],0
JE dicha_calidad
ADD BX,4
JMP busca_calidad
dicha_calidad: MOV DX,[BX+2]
CALL print ; imprimir mensaje de calidad
LEA DX,spinf3_txt
CALL print
RET
fallo_sp: POPF ; **2
POP SI ; *2
LEA DX,spine_txt
CALL print ; fallo del test
RET
informe_spin ENDP
; ------------ Rutina para dividir números de 48 por números de 15
; bits sin desbordamientos y con cociente de 48 bits.
; DXDISI/AX --> cociente en DXDISI y resto en AX.
; No se modifican otros registros. No se comprueba si
; el divisor es cero o excede los 15 bits.
divi48x15 PROC
PUSH BX
PUSH CX
XOR BX,BX
MOV CX,49 ; rotar 49 veces
divi48_15_cmp: CMP AX,BX
JA divi48_nosub
SUB BX,AX
STC
divi48_nosub: RCL SI,1
RCL DI,1
RCL DX,1
PUSHF
CMP CX,1
JE divi48_resto ; ¡no rotar el resto al final!
POPF
RCL BX,1
PUSHF
divi48_resto: POPF
LOOP divi48_15_cmp
MOV AX,BX
POP CX
POP BX
RET
divi48x15 ENDP
; ------------ Obtener la unidad física correspondiente a la unidad
; 2MGUI o a la indicada. Si la que se indica no es
; además 2MGUI, CF=1 a la vuelta.
get_drv PROC
MOV AL,disquetera
CMP AL,-1
JNE usar_esa
MOV AL,0
CMP instalado,ON
JNE usar_esa ; la A: si no instalado
PUSH ES
MOV ES,tsr_seg
MOV AL,ES:unidad_base ; por defecto la primera
POP ES
MOV disquetera,AL
usar_esa: CALL drv2mgui?
RET
get_drv ENDP
; ------------ Comprobar si la unidad AL es 2MGUI y devolver en
; ese caso su número físico. AH corrompido.
drv2mgui? PROC
MOV AH,0
CMP instalado,ON
JNE drvn2mg ; si no instalado, no 2MGUI
PUSH ES
MOV ES,tsr_seg
MOV AH,ES:unidad_base
POP ES
SUB AL,AH
JZ drv2mg ; primera unidad 2MGUI
CMP num_discos,1
JE drvn2mg
CMP AL,1
JE drv2mg ; segunda unidad 2MGUI
drvn2mg: ADD AL,AH
STC
RET
drv2mg: MOV AH,info_E.unidad ; primera unidad
AND AL,AL
JZ drv2mg_ok
MOV AH,info_F.unidad ; segunda unidad
drv2mg_ok: MOV AL,AH
CLC
RET
drv2mgui? ENDP
; ------------ Comprobar si la unidad AL es 2MGUI, A: ó B:
drvfloppy? PROC
CMP AL,1
JA es2mgui? ; no es A: ni B:
MOV DL,AL
MOV AH,8
MOV BL,0
CALL tipo_disco ; tipo de la unidad
CMP BL,2
JE drvflp ; de alta densidad
CMP BL,4
JAE drvflp ; de alta densidad
es2mgui?: CALL drv2mgui?
RET
drvflp: CLC
RET
drvfloppy? ENDP
; ------------ Inicializar datos para las rutinas de bajo nivel.
; A la entrada, AL = unidad física.
init_flp PROC
PUSH AX
LEA SI,info_E ; apuntar a datos de la unidad
MOV BX,GAPDEF
MOV CL,modoDMA
CMP instalado,ON
JNE flpn_ok ; usar la primera si no reside
PUSH ES
MOV ES,tsr_seg
MOV BX,ES:gaprw
MOV CL,ES:modoDMA
CMP AL,ES:info_E.unidad ; utilizar la correcta si el
POP ES ; programa está residente
JE flpn_ok
LEA SI,info_F
flpn_ok: MOV [SI].unidad,AL ; en adelante, la unidad física
MOV gaprw,BX
MOV modoDMA,CL ; GAP/modo DMA correcto
CALL get_tpista
MOV [SI].infb.tpista1,AX ; bytes por pista 1ª parte
MOV [SI].infb.tpista2,BX ; bytes por pista 2ª parte
MOV tpistamax1,CX ; bytes máximos teóricos 1ª parte
MOV tpistamax2,DX ; bytes máximos teóricos 2ª parte
MOV BL,7 ; log2 (16384) - 7 = 7
CMP AX,16384
JBE tsecf_ok
INC BL ; log2 (32768) - 7 = 8
tsecf_ok: MOV [SI].tsector,BL
MOV AX,DI
MOV [SI].vunidad1,AL
MOV [SI].infb.vunidad2,AH
MOV AX,bsectini
MOV [SI].bytes_sector,AX
POP AX
RET
init_flp ENDP
; ------------ Devolver tamaño de la pista (para la unidad AL)
; en AX (pistas 1ª parte) y BX (2ª parte) así como los
; límites máximos en CX (1ª parte) y DX (2ª parte) y
; las velocidades de transferencia en DI.
get_tpista PROC
MOV DL,AL
MOV AH,8
CALL tipo_disco ; tipo de la unidad
LEA AX,pista_525
CMP BL,2
JE infpis_ok ; 1.2M
LEA AX,pista_35
CMP BL,4 ; 1.44M
JE infpis_ok
CMP param_ed,ON
JNE infpis_ok
LEA AX,pista_ed ; 2.88M
infpis_ok: MOV BX,10 ; offset información DD
CMP param_dd,ON
JE infdis_ok
MOV BX,20 ; offset información DH
CMP param_dh,ON
JE infdis_ok
XOR BX,BX ; offset información HD
infdis_ok: ADD BX,AX ; direccionar tabla datos
MOV AX,tpista
CMP param_b,ON
JE tp1_ok ; indicado con /B
MOV AX,[BX]
tp1_ok: MOV CX,[BX+2]
MOV DX,[BX+6]
MOV DI,[BX+8]
MOV BX,[BX+4]
CMP param_b,ON
JNE tp2_ok
CMP param_dh,ON
JNE tp3_ok
XPUSH <SI, DI, CX, DX> ; * caso 5¼ /DH
MUL WORD PTR maxpistas
MOV DI,DX
MOV SI,AX
MOV AX,t_525_hd ; tamaño * maxpistas * t_525_hd
CALL mult32x16
MOV AX,20
CALL divi48x15 ; div 20 (problema de rango)
XPUSH <DX, DI, SI>
MOV AX,WORD PTR maxpistas
SUB AL,frontera
SBB AH,0
MOV BX,t_525_dd
MUL BX
MOV CX,DX
MOV BX,AX ; CX:BX = t_525_dd*(maxp - FRO)
XOR DI,DI
MOV SI,t_525_hd
MOV AL,frontera
MOV AH,0
CALL mult32x16
ADD SI,BX
ADC DI,CX
ADC DX,0 ; denominador
MOV AX,20
SUB SI,24 ; redondeo
SBB DI,0
SBB DX,0
CALL divi48x15 ; div 20 (problema de rango)
MOV AX,SI ; cabe en 15 bits
XPOP <SI, DI, DX>
CALL divi48x15
INC SI ; redondeo por el resto
MOV AX,SI ; tamaño primera parte disco
PUSH AX ; **
MOV BX,t_525_dd
MUL BX
MOV BX,t_525_hd
DIV BX
MOV BX,AX ; tamaño segunda parte disco
POP AX ; **
XPOP <DX, CX, DI, SI> ; *
JMP tp2_ok
tp3_ok: MOV BX,AX ; /B afecta a todo el disco
tp2_ok: RET
get_tpista ENDP
; ------------ Imprimir nº de 8 bits en AL.
print_8 PROC
XPUSH <AX, CX, DX>
MOV AH,0
XOR DX,DX
MOV CL,2
CALL print_32
XPOP <DX, CX AX>
RET
print_8 ENDP
; --- Imprimir un nº decimal de 32 bits en DXAX formateado por CL.
;
; Entradas:
; Si bit 4 = 1 --> se imprimirán signos separadores de millar
; bits 0-3 = nº total de dígitos (incluyendo separadores de
; millar y parte fraccional)
; bits 5-7 = nº de dígitos de la parte fraccional (cuantos
; dígitos de DXAX, empezando por la derecha,
; se consideran parte fraccional, e irán precedidos
; del correspondiente separador)
;
; Salidas: nº impreso, ningún registro modificado.
;
; * Ejemplo, si DXAX=9384320 y CL=010 1 1011
; se imprimirá ( '_' representa un espacio en blanco ): __93.843,20
print_32 PROC
PUSH DS
PUSH ES
PUSH CS
PUSH CS
POP DS
POP ES
PUSH AX ; preservar todos los registros
PUSH BX
PUSH CX
PUSH DX
PUSH SI
PUSH DI
PUSHF
MOV formato_pr32,CL ; byte del formato de impresión elegido
MOV CX,",."
CMP idioma_sp,ON
JE separ_pr32
XCHG CH,CL
separ_pr32: MOV millares_pr32,CL ; separador de millares
MOV fracc_pr32,CH ; separador parte fraccional
MOV BX,OFFSET tabla_pr32
MOV CX,10
digit_pr32: PUSH CX
PUSH AX
PUSH DX
XOR DI,DI
MOV SI,1 ; DISI = 1
DEC CX ; CX - 1
JCXZ hecho_pr32
factor_pr32: SAL SI,1
RCL DI,1 ; DISI * 2
MOV DX,DI
MOV AX,SI
SAL SI,1
RCL DI,1
SAL SI,1
RCL DI,1 ; DISI * 8
ADD SI,AX
ADC DI,DX ; DISI = DISI*8 + DISI*2 = DISI*10
LOOP factor_pr32 ; DISI = DISI*10*10* ... (CX-1 veces)
hecho_pr32: POP DX ; luego DISI = 10 elevado a (CX-1)
POP AX ; CX se recuperará más tarde
MOV CL,0FFh
rep_sub_pr32: INC CL
SUB AX,SI
SBB DX,DI ; DXAX = DXAX - DISI
JNC rep_sub_pr32 ; restar el factor cuanto se pueda
ADD AX,SI ; subsanar el desbordamiento:
ADC DX,DI ; DXAX = DXAX + DISI
ADD CL,'0' ; pasar binario a ASCII
MOV [BX],CL
POP CX ; CX se recupera ahora
INC BX
LOOP digit_pr32 ; próximo dígito del número
STD ; transferencias (MOVS) hacia atrás
DEC BX ; BX apunta al último dígito
MOV final_pr32,BX ; último dígito
MOV ent_frac_pr32,BX ; frontera parte entera/fraccional
MOV CL,5
MOV AL,formato_pr32
SHR AL,CL ; AL = nº de decimales
AND AL,AL
JZ no_frac_pr32 ; ninguno
MOV CL,AL
XOR CH,CH
MOV SI,final_pr32
MOV DI,SI
INC DI
REP MOVSB ; correr cadena arriba (hacer hueco)
INC final_pr32
MOV AL,fracc_pr32
MOV [DI],AL ; poner separador de parte fraccional
MOV ent_frac_pr32,SI ; indicar nueva frontera
no_frac_pr32: MOV AL,formato_pr32
TEST AL,16 ; interpretar el formato especificado
JZ poner_pr32 ; imprimir como tal
entera_pr32: MOV CX,final_pr32 ; añadir separadores de millar
SUB CX,ent_frac_pr32
ADD CX,3
MOV SI,final_pr32
MOV DI,SI
INC DI
REP MOVSB ; correr cadena arriba (hacer hueco)
MOV AL,millares_pr32
MOV [DI],AL ; poner separador de millares
INC final_pr32
MOV ent_frac_pr32,SI ; usar esta variable como puntero
SUB SI,OFFSET tabla_pr32
CMP SI,3
JAE entera_pr32 ; próximo separador
poner_pr32: MOV BX,final_pr32
MOV BYTE PTR [BX+1],0 ; delimitador de fin de cadena
MOV BX,OFFSET tabla_pr32
MOV principio_pr32,BX ; inicio de cadena
limpiar_pr32: MOV AL,[BX]
CMP AL,'0'
JE blanco_pr32 ; cero a la izda --> poner " "
CMP AL,millares_pr32 ; separador millares a la izda
JE blanco_pr32
CMP AL,fracc_pr32
JNE acabar_pr32
MOV BYTE PTR [BX-1],'0' ; reponer 0 antes de la coma
DEC principio_pr32
acabar_pr32: MOV AL,formato_pr32 ; imprimir
AND AL,00001111b
XOR AH,AH
MOV DX,final_pr32
SUB DX,AX
INC DX ; DX = offset 'principio'
AND AX,AX
JNZ format_pr32 ; longitud especificada por el usuario
MOV DX,principio_pr32 ; longitud obtenida del número
format_pr32: CALL print
POPF ; restaurar todos los registros
POP DI
POP SI
POP DX
POP CX
POP BX
POP AX
POP ES
POP DS
RET ; salida del procedimiento
blanco_pr32: MOV BYTE PTR [BX],' ' ; sustituir 0 ó separador de millares
INC BX ; a la izda. por espacio en blanco
INC principio_pr32
CMP BX,final_pr32
JB limpiar_pr32
MOV DX,BX ; es el número 0.000.000.00X
JMP SHORT acabar_pr32 ; imprimir
formato_pr32 DB 0
DB 5 DUP (' ') ; espacios en blanco para cubrir la
; mayor plantilla que pueda ser espe-
; cificada en el formato
tabla_pr32 DT 0 ; reservar 14 bytes (nº más ., más ASCIIZ)
DW 0,0 ; aquí se solapa un buffer de 32 bytes
millares_pr32 DB '.' ; separador de millares
fracc_pr32 DB ',' ; " parte fraccional
final_pr32 DW 0 ; offset al último byte a imprimir
principio_pr32 DW 0 ; " " primer " " "
ent_frac_pr32 DW 0 ; offset a la frontera entero-fracc.
DT 0 ; $ - tabla_pr32 = 32 bytes usados por
; INT 21h al principio de print_32
print_32 ENDP
; ------------ Crear tabla con información para formatear.
genera_infof PROC
XPUSHA
PUSH ES
MOV ES,sbuffer
MOV AL,[SI].infb.mfrontera
CMP [SI].cilindro,AL ; 1ª/2ª mitad del disco
MOV AX,tpistamax1
JB pl_ok
MOV AX,tpistamax2
pl_ok: SUB AX,146 ; respetar inicio pista
XOR DX,DX
MOV CX,256+62+PRE_GAP3
DIV CX ; AX sectores de 256 bytes caben
MOV CX,AX
MOV BX,360 ; grados de la circunferencia
MOV AX,sliding_x
MUL CX
DIV BX ; AL = sliding X en sectores
PUSH AX ; *
MOV AX,sliding_y
MUL CX
DIV BX ; AL = sliding Y en sectores
POP BX ; *
MOV AH,AL ; sliding Y
MOV AL,BL ; sliding X
PUSH AX ; *
ADD AL,AH
MOV AH,[SI].cilindro
INC AH ; desplazar incluso cilindro 0
MUL AH ; (cilindro+1) * (X+Y)
MOV DX,AX
POP AX ; *
MUL [SI].cabezal ; cabezal * X
ADD AX,DX
XOR DX,DX ; DX:AX = cil * (X+Y) + cab * X
DIV CX ; DL = DX:AX MOD sectores = dis
SUB DL,CL
NEG DL ; DL = sectores - dis
INC DL ; primer_sector
CMP DL,CL
JB gen_ps_ok
MOV DL,0
gen_ps_ok: MOV BL,CL ; nº sectores
MOV AL,[SI].cabezal
MOV AH,1
XOR DI,DI
MOV ES:[DI],CL ; sectores
MOV ES:[DI+1],AH ; de tamaño 1 (256 bytes)
MOV DH,[SI].cilindro
ADD DI,2
gen_info: MOV ES:[DI],DH ; cilindro
MOV ES:[DI+1],AL ; cabezal
MOV ES:[DI+2],DL ; sector
MOV ES:[DI+3],AH ; tamaño 1 (256 bytes)
AND DL,DL
JNZ gen_tam_ok
MOV AH,[SI].tsector
MOV ES:[DI+3],AH ; el sector 0 es especial
MOV AH,1
gen_tam_ok: INC DL
CMP DL,BL
JB gen_sec_ok
MOV DL,0 ; comenzar desde sector 0
gen_sec_ok: ADD DI,4
LOOP gen_info
POP ES
XPOPA
RET
genera_infof ENDP
; ------------ Formatear una pista.
formatea_pista PROC
XPUSHA ; *
PUSH ES ; **
MOV ES,sbuffer
MOV CL,ES:[0]
MOV CH,0 ; CX sectores
SHL CX,1
SHL CX,1
DEC CX ; nº de bytes - 1
MOV AX,ES
MOV DI,2
CALL calc_dir_DMA ; AX:DI -> base BX y página AH
MOV AL,F_WRITE ; modo DMA para escribir
CALL _prepara_DMA ; programar realmente el DMA
MOV AL,F_FORMAT
CALL fdc_write
JC fallo_fmt
MOV AL,[SI].cabezal
SHL AL,1
SHL AL,1
OR AL,[SI].unidad
CALL fdc_write ; byte 1 de la orden
JC fallo_fmt
MOV AL,ES:[1]
CALL fdc_write ; tamaño general
JC fallo_fmt
MOV AL,ES:[0]
CALL fdc_write ; nº sectores
MOV AL,PRE_GAP3
CALL fdc_write ; GAP3
MOV AL,4Eh
CALL reset_irq
CALL fdc_write ; byte de relleno 4Eh (GAP)
CALL espera_int
fallo_fmt: PUSHF
LEA BX,fdc_result
MOV CX,7
format_res: CALL fdc_read ; leyendo resultados
MOV [BX],AL
INC BX
LOOP format_res
POPF
JC fallo_format
TEST fdc_result,11000000b
JZ format_ret
fallo_format: STC ; fallo
CALL set_err
format_ret: POP ES ; **
XPOPA ; *
RET
formatea_pista ENDP
; ------------ Devolver nº aleatorio de 16 bits en AX.
rnd PROC
CMP semilla,0
JNE dev_rnd
PUSH DS
MOV AX,40h
MOV DS,AX
MOV AX,DS:[6Ch] ; contador hora BIOS
POP DS ; como semilla
MOV semilla,AX
dev_rnd: XPUSH <BX, CX>
MOV AX,semilla
MOV BX,AX
MOV CL,7
SHR AX,CL
XOR AX,BX
AND AX,1
ROR AX,1
SHR BX,1
OR AX,BX
MOV semilla,AX
XPOP <CX, BX>
RET
semilla DW 0
rnd ENDP
; ***********************************************
; * *
; * D A T O S N O R E S I D E N T E S *
; * *
; ***********************************************
; ------------ Parámetros soportados
param_ayuda DB OFF ; a ON si se indicó /? /H ó ?
param_dd DB OFF ; a ON si se indicó /DD
param_dh DB OFF ; a ON si se indicó /DH
param_ed DB OFF ; a ON si se indicó /ED
param_dron DB OFF ; a ON si se indicó /DRON
param_droff DB OFF ; a ON si se indicó /DROFF
param_dwon DB OFF ; a ON si se indicó /DWON
param_dwoff DB OFF ; a ON si se indicó /DWOFF
param_n DB OFF ; a ON si se indicó /N
param_k DB OFF ; a ON si se indicó /K
param_test DB OFF ; a ON si se indicó /TEST
param_nodma DB OFF ; a ON si se indicó /NODMA
param_ems DB OFF ; a ON si se indicó /EMS
param_q DB OFF ; a ON si se indicó /Q
param_t DB OFF ; a ON si se indicó /T=
param_r DB OFF ; a ON si se indicó /R=
param_c DB OFF ; a ON si se indicó /C=
param_s DB OFF ; a ON si se indicó /S=
param_f DB OFF ; a ON si se indicó /F=
param_b DB OFF ; a ON si se indicó /B=
param_x DB OFF ; a ON si se indicó /X=
param_y DB OFF ; a ON si se indicó /Y=
param_m DB OFF ; a ON si se indicó /M=
param_g DB OFF ; a ON si se indicó /G=
ptr_label DW 0 ; != NULL si se indicó /L
ptr_ilabel DW 0 ; != NULL si se indicó /V
disquetera DB -1 ; unidad seleccionada si se indica
parametros LABEL BYTE
DB "*:",3
DB 'A'
DB 26
DW disquetera
DB "?",0
DW param_ayuda
DB ON
DB "/?",0
DW param_ayuda
DB ON
DB "/H",0
DW param_ayuda
DB ON
DB "/DD",0
DW param_dd
DB ON
DB "/DH",0
DW param_dh
DB ON
DB "/ED",0
DW param_ed
DB ON
DB "/DRON",0
DW param_dron
DB ON
DB "/DROFf",0
DW param_droff
DB ON
DB "/DWON",0
DW param_dwon
DB ON
DB "/DWOFf",0
DW param_dwoff
DB ON
DB "/TEst",0
DW param_test
DB ON
DB "/NOdma",0
DW param_nodma
DB ON
DB "/EMs",0
DW param_ems
DB ON
DB "/B",1
DW 0, MPISTA
DW tpista
DW param_b
DB ON
DB "/X",1
DW 0, 359
DW sliding_x
DW param_x
DB ON
DB "/Y",1
DW 0, 359
DW sliding_y
DW param_y
DB ON
DB "/M",1
DW 0, 86
DW frontera
DW param_m
DB ON
DB "/G",1
DW 0, 999
DW gaprw
DW param_g
DB ON
DB "/N",0
DW param_n
DB ON
DB "/K",0
DW param_k
DB ON
DB "/I",0
DW param_i
DB ON
DB "/Q",0
DW param_q
DB ON
DB "/T",1
DW 80, 86
DW maxpistas
DW param_t
DB ON
DB "/C",2
DW 8,128,256,512,1024,2048,4096,8192,16384
DW tcluster
DW param_c
DB ON
DB "/S",2
DW 3,128,256,512
DW bsectini
DW param_s
DB ON
DB "/R",1
DW 1, 240
DW rootdir
DW param_r
DB ON
DB "/F",1
DW 1, 2
DW nfats
DW param_f
DB ON
DB "/L",4
DW ptr_label
DB "/V",4
DW ptr_ilabel
DB 0 ; fin de la tabla
; ------------ Constantes y variables
ON EQU 1 ; constantes booleanas
OFF EQU 0
ERRSINTAX EQU 1 ; tipos de errores
MALDOS EQU 2
MALDRV EQU 4
MALBIOS EQU 8
ERRRANGO EQU 16
POCAMEM EQU 32
YAINST EQU 64
NOINST EQU 128
MX64FULL EQU 256
DMACRUCE EQU 512
DMAPOCO EQU 1024
PARAMCONFIG EQU 2048
ABORTADO EQU 8
NOPREP EQU 16
MALADENS EQU 32
PROTESCR EQU 64
MALSYS EQU 128
MUCHAFAT EQU 256
MUCHAPISTA EQU 512
error DW 0 ; de instalación
errw DW 0 ; al formatear/test, etc.
disco DB ?
emmtipo DW ? ; tipo de EMM en INT 4Bh
psp DW ? ; dirección del PSP
emm_id DB "EMMXXXX0" ; identificación controlador EMS
emm_nombre DB "2MGUI",0,0,0 ; nombre para el handle EMS
null DB "NUL",0 ; dispositivo NUL
instalado DB ? ; a ON si 2MGUI instalado
offsets_ints DW 3 ; número de vectores interceptados
DB 8h ; tabla de offsets de los vectores
DW ges_int08 ; de interrupción interceptados
DB 13h
DW ges_int13
DB 2Fh
DW ges_int2F
; --- El disco está dividido en dos partes: desde el
; cilindro 0 hasta FRONTERA-1 y desde FRONTERA
; hasta maxpistas-1. Cada parte tiene sus propias
; características (en la práctica, sólo en 360DH).
pista_525 LABEL WORD
DW t_525_hd ; 1.2M 1ª parte HD
DW m_525_hd ; límite físico 1ª parte HD
DW t_525_hd ; 1.2M 2ª parte HD
DW m_525_hd ; límite físico 2ª parte HD
DW 0000h ; velocidad
DW t_525_dd ; 1.2M 1ª parte DD
DW m_525_dd ; límite físico 1ª parte DD
DW t_525_dd ; 1.2M 2ª parte DD
DW m_525_dd ; límite físico 2ª parte DD
DW 0101h ; velocidad
DW t_525_hd ; 1.2M 1ª parte DH
DW m_525_hd ; límite físico 1ª parte DH
DW t_525_dd ; 1.2M 2ª parte DH
DW m_525_dd ; límite físico 2ª parte DH
DW 0100h ; velocidad
pista_35 LABEL WORD
DW t_35_hd ; 1.44M 1ª parte HD
DW m_35_hd ; límite físico 1ª parte HD
DW t_35_hd ; 1.44M 2ª parte HD
DW m_35_hd ; límite físico 2ª parte HD
DW 0000h ; velocidad
DW t_35_dd ; 1.44M 1ª parte DD
DW m_35_dd ; límite físico 1ª parte DD
DW t_35_dd ; 1.44M 2ª parte DD
DW m_35_dd ; límite físico 2ª parte DD
DW 0101h ; velocidad
DW t_35_dd ; 1.44M 1ª parte DD
DW m_35_dd ; límite físico 1ª parte DD
DW t_35_dd ; 1.44M 2ª parte DD
DW m_35_dd ; límite físico 2ª parte DD
DW 0101h ; velocidad
pista_ed LABEL WORD
DW t_35_ed ; 2.88M 1ª parte ED
DW m_35_ed ; límite físico 1ª parte ED
DW t_35_ed ; 2.88M 2ª parte ED
DW m_35_ed ; límite físico 2ª parte ED
DW 0303h ; velocidad
DW t_35_ed ; 2.88M 1ª parte ED
DW m_35_ed ; límite físico 1ª parte ED
DW t_35_ed ; 2.88M 2ª parte ED
DW m_35_ed ; límite físico 2ª parte ED
DW 0303h ; velocidad
DW t_35_ed ; 2.88M 1ª parte ED
DW m_35_ed ; límite físico 1ª parte ED
DW t_35_ed ; 2.88M 2ª parte ED
DW m_35_ed ; límite físico 2ª parte ED
DW 0303h ; velocidad
maxpistas DB PISTAS
DB 0 ; ¡la captura de parámetros usa DW, no DB!
rootdir DW MINROOT ; mínimo por defecto
bsectini DW SECTDEF ; tamaño de sector por defecto
tcluster DW CLUSDEF ; tamaño de clúster por defecto
nfats DB 1
DB 0 ; ¡la captura de parámetros usa DW, no DB!
tipofat DB ?
fbuffer DW 0 ; segmento para la FAT
srootdir DW ? ; sectores ocupados por el raíz
tpista DW ? ; valor de /B= si se indica
tpistamax1 DW ? ; bytes por pista físicamente máximos
tpistamax2 DW ? ; ...y en la segunda parte del disco
sliding_x DW SLID_X ; grados angulares de sliding /X
sliding_y DW SLID_Y ; grados angulares de sliding /Y
frontera DB FRONT ; frontera división del disco 2 mitades
DB 0 ; ¡la captura de parámetros usa DW, no DB!
tmodo DB ? ; 0->pista a 0, 1->con datos aleatorios
bytes_ok DW ? ; bytes bien leídos durante el test
bytes_max DW ? ; máximos bytes soportados último éxito
tmax DW ? ; máximo/mínima capacidad por pista
tmin DW ? ; durante el test
iter DW ? ; contador de iteraciones
irq6 DB ? ; a ON cuando llega dicha IRQ en el test
cnt_h DW ? ; contadores de tiempo para spin
cnt_l DW ?
dif_l DW 0 ; variación de los contadores
dif_h DW 0
cntms_h DW 0 ; milisegundos * 1000
cntms_l DW 0
dif0_l DW 0 ; valor inicial
dif0_h DW 0
sector_boot LABEL BYTE ; sector de arranque de 128 bytes
JMP SHORT arranque
NOP
DB "2MGUI-10" ; ID sistema: versión 1.0
boot_tsect DW ? ; bytes/sector
bscluster DB ? ; sectores por cluster
DW 1 ; sectores reservados al principio
bnfats DB ? ; nº copias de la FAT
brootdir DW ? ; entradas al directorio raíz
bsectores DW ? ; nº total de sectores del disco
media_id DB 0FAh ; byte descriptor de medio
bsectfat DW ? ; sectores ocupados por la FAT
DW 1 ; sectores por pista
DW 1 ; nº de cabezales
DD 0 ; sectores especiales reservados
DD 0 ; nº sectores (unidad 32 bit)
DB 0 ; unidad física
DB 0 ; reservado
DB 29h ; disco con número de serie
bserie DD 12345678h ; número de serie
DB "NO NAME " ; título del disco
ftipo DB "FAT12 " ; tipo de FAT
arranque: CLI
HLT
DB "(C) 1995 "
DB "Ciriaco García de Celis - "
DB "Valladolid/Spain"
DB 0
PINFOBOOT EQU 74h ; offset físico del área con información
bootp InfoBoot <> ; información del BOOT
DB 126 DUP (0)
DW 0AA55h ; para el DOS, por si es de 256 bytes
DB 254 DUP (0)
DW 0AA55h ; para el DOS, por si es de 512 bytes
; --- Información IOCTL por defecto.
info_drv120 DB 4, 1 ; sectores iguales / tipo 1.2M
DW 2, 13118 ; detecta cambio / nº pistas
DB 0 ; tipo de soporte
DW 128 ; BPB: bytes por sector
DB 8 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 1 ; BPB: número de FATs
DW 132 ; BPB: entradas en el raíz
DW 13118 ; BPB: nº total de sectores
DB 0FAh ; BPB: descriptor de medio
DW 20 ; BPB: sectores por FAT
DW 1, 1 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
info_drv144 DB 4, 7 ; sectores iguales / tipo 1.44M
DW 2, 15776 ; detecta cambio / nº pistas
DB 0 ; tipo de soporte
DW 128 ; BPB: bytes por sector
DB 8 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 1 ; BPB: número de FATs
DW 156 ; BPB: entradas en el raíz
DW 15776 ; BPB: nº total de sectores
DB 0FAh ; BPB: descriptor de medio
DW 24 ; BPB: sectores por FAT
DW 1, 1 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
info_drv288 DB 4, 9 ; sectores iguales / tipo 2.88M
DW 2, 31552 ; detecta cambio / nº pistas
DB 0 ; tipo de soporte
DW 128 ; BPB: bytes por sector
DB 16 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 1 ; BPB: número de FATs
DW 156 ; BPB: entradas en el raíz
DW 31552 ; BPB: nº total de sectores
DB 0FAh ; BPB: descriptor de medio
DW 24 ; BPB: sectores por FAT
DW 1, 1 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
; ------------ Mensajes de instalación.
programa_txt DB 13,10,"2MGUI 1.0 ",13,10,0
instalado_txt DB " Instalado en unidad(es) "
tabla_letras1 DB "A: ",13,10,255
DB " Installed on drive(s) "
tabla_letras2 DB "A: ",13,10,0
errxtdma_txt DB " - Nota: Sistema PC/XT, soportado sólo modo DMA.",13,10,255
DB " - Note: PC/XT system, supported only DMA mode.",13,10,0
erremsins_txt DB " - Nota: No ha sido posible utilizar memoria EMS.",13,10,255
DB " - Note: It isn't possible to use EMS memory.",13,10,0
erremsdma_txt DB " - Nota: Sólo se puede utilizar EMS en modo /NODMA.",13,10,255
DB " - Note: To use EMS is only possible in /NODMA mode.",13,10,0
mal_dos_txt DB " - Error: Necesario DOS 3.30 o posterior.",13,10,255
DB " - Error: Needs DOS 3.30 or above.",13,10,0
mal_bios_txt DB " - Error: No puedo detectar el tipo de las unidades. Instale 2M-?BIOS antes.",13,10,255
DB " - Error: Impossible to detect drive types. Please install 2M-?BIOS before.",13,10,0
mal_drv_txt DB " - Error: Necesaria(s) unidad(es) de alta densidad.",13,10,255
DB " - Error: Needs high-density floppy drive(s).",13,10,0
ya_ins_txt DB " - Error: Programa ya instalado en memoria.",13,10,255
DB " - Error: Program already loaded on memory.",13,10,0
dma_front_txt DB " - Consejo: Modifique la ubicación en memoria de este programa (variando el",13,10
DB " orden de instalación de dispositivos) o, alternativamente, pruebe",13,10
DB " a instalarlo en modo NO-DMA. El motivo es economizar memoria, ya",13,10
DB " que se cruza una frontera de DMA. No obstante, el programa puede",13,10
DB " funcionar perfectamente así, ocupando más memoria.",13,10,255
DB " - Advice: Modify the memory location of this utility (variying the devices",13,10
DB " installation order) or install the program in Non-DMA mode, to save",13,10
DB " memory. The problem is that 2MGUI crosses a DMA frontier. But this",13,10
DB " program can work correctly in this way (taking more memory).",13,10,0
dma_poco_txt DB " - Nota: El buffer DMA de su controlador de memoria es demasiado pequeño,",13,10
DB " auméntelo a 13 (1.44M) ó 25 (2.88M) Kbytes.",255
DB " - Note: The DMA buffer of your memory manager is too small; set it",13,10
DB " to 13 (1.44M) or 25 (2.88M) Kbytes.",0
emm_qemm_txt DB " En su controlador de",13,10
DB " memoria (QEMM) basta que le añada la opción DMA=13 ó DMA=25.",13,10,255
DB " With your memory manager (QEMM) you must add",13,10
DB " to it a DMA=13 or DMA=25 switch.",13,10,0
nocabe_txt DB " Instalación imposible:",13,10
DB " Ya hay 64 programas residentes con la misma técnica.",13,10,255
DB " Unable to install:",13,10
DB " There are already 64 TSR's with the same technique.",13,10,0
err_sintax_txt DB " - Error de sintaxis o parámetro fuera de rango.",13,10,255
DB " - Syntax error or parameter out of range.",13,10,0
pet_ayuda_txt DB " Ejecute 2MGUI /? si desea obtener ayuda.",13,10,255
DB " Execute 2MGUI /? to obtain more help.",13,10,0
no_ins_txt DB " - Error: Instale este programa primero en CONFIG.SYS",13,10,255
DB " - Error: First, install this program in CONFIG.SYS",13,10,0
err_mem_txt DB " - Error: memoria insuficiente.",13,10,255
DB " - Error: insufficient memory.",13,10,0
; ------------ Mensajes varios.
limpia_txt DB 13," ",13,0
lin_txt DB "───────────────────────────────────────────────────────────────────────────────",13,10,0
err_prot_txt DB 13," - Disco protegido contra escritura.",13,10,255
DB 13," - Write protected disk error.",13,10,0
no_prep_txt DB 13," - Unidad no preparada.",13,10,255
DB 13," - Drive not ready.",13,10,0
mal_dens_txt DB 13," - Anomalía general. ¿Densidad incorrecta?.",13,10,255
DB 13," - General failure. Incorrect density?.",13,10,0
mal_unidad_txt DB " - La unidad no existe o no es de alta densidad.",13,10,255
DB " - Diskette drive doesn't exist or it isn't high-density.",13,10,0
dh_test_txt DB " - El parámetro /DH no puede indicarse junto a /TEST.",13,10,255
DB " - The /DH switch can not be used with /TEST.",13,10,0
pconfig_txt DB " - El parámetro /NODMA sólo puede indicarse en CONFIG.SYS o con /TEST; y ",13,10
DB " el parámetro /EMS sólo puede indicarse en CONFIG.SYS y junto a /NODMA.",13,10,255
DB " - The /NODMA switch can only be used in CONFIG.SYS or with /TEST; and",13,10
DB " the /EMS switch can only be used in CONFIG.SYS and with /NODMA.",13,10,0
crlf_txt DB 13,10,0
; ------------ Informe de unidades.
hay_2mgui_txt DB 13,10
DB "2MGUI 1.0 ya instalado en memoria.",13,10,255
DB 13,10
DB "2MGUI 1.0 already installed in memory.",13,10,0
hay_en_txt DB " - Nueva unidad ",255
DB " - New drive ",0
nueva_u DB "E: ",0
hay2_txt DB " (unidad física ",255
DB " (physical drive ",0
vieja_u DB "A"
DB ":)",13,10,0
gap_txt DB " - GAP anti-FIFO de",255
DB " - Anti-FIFO GAP of",0
dma1_txt DB " bytes y modo ",255
DB " bytes and ",0
dmano_txt DB "NO-",255,"non-",0
dma2_txt DB "DMA.",13,10,255
DB "DMA mode.",13,10,0
buffer_ems_txt DB " - Buffer interno ubicado en memoria EMS.",13,10,255
DB " - Internal buffer placed in EMS memory.",13,10,0
cache_off_txt DB " - Escritura retardada desactivada.",13,10,255
DB " - Delayed-write disabled.",13,10,0
sopdr_on_txt DB " - Soporte para DISKCOPY DR-DOS y Novell DOS activo.",13,10,255
DB " - DR-DOS and Novell DOS DISKCOPY support enabled.",13,10,0
; ------------ Mensajes de formateo.
no_2mgui_txt DB 13,10,"2MGUI 1.0",13,10
DB " - Error: La unidad indicada no es un dispositivo 2MGUI.",13,10,255
DB 13,10,"2MGUI 1.0",13,10
DB " - Error: Drive indicated does not is a 2MGUI device.",13,10,0
mucha_fat_txt DB 13,10,"2MGUI 1.0",13,10
DB " - Error: Memoria insuficiente para una FAT tan grande.",13,10,255
DB 13,10,"2MGUI 1.0",13,10
DB " - Error: Insufficient memory for so big a FAT.",13,10,0
fmtm1_txt DB 13,10,"2MGUI 1.0 Formateando",255
DB 13,10,"2MGUI 1.0 Formatting",0
fmtm2_txt DB " bytes por pista en ",255
DB " bytes per track in ",0
fmtm3_txt DB ": ",0
fmtm4_txt DB " (ESC Salir)",13,10,255
DB " (ESC Aborts)",13,10,0
fmtm5_txt DB " Inicializando disquete de ",255," Initializing ",0
fmtm6_txt DB " con",255," diskette with",0
fmtm7_txt DB "K",13,10,0
pausaf_txt DB " Pulsa INTRO para formatear u otra tecla para terminar...",255
DB " Press ENTER key to begin format or another key to exit...",0
abortado_txt DB 13," - Formateo interrumpido por el usuario.",13,10,255
DB 13," - Format aborted by user. ",13,10,0
mucha_pis_txt DB 13," - La unidad no soporta tanta capacidad en la pista.",13,10,255
DB 13," - This drive doesn't support so big a track.",13,10,0
mal_sys_txt DB 13," - Fatal: fallo en áreas del sistema.",13,10,255
DB 13," - Fatal: failure on system areas.",13,10,0
cil_txt DB 13," Cilindro ",255,13," Cylinder ",0
cab_txt DB " Cara",255," Side",0
p_txt DB " ",0
f_txt DB 8,8,8,8,8,"[F--]",0
w_txt DB 8,8,8,8,8,"[-X-]",0
v_txt DB 8,8,8,8,8,"[--V]",0
error_txt DB 13,10,"Error",0
t_drvs DW t360, t1200, t720, t1440, t2880, t2880
t360 DB "360K",0
t1200 DB "1.2M",0
t720 DB "720K",0
t1440 DB "1.44M",0
t2880 DB "2.88M",0
capacidad1_txt DB 13," Espacio bruto en disco de",255
DB 13," Crude disk space is",0
capacidad2_txt DB " bytes.",13,10,0
etiq_txt DB " Etiqueta de volúmen ",255
DB " Volume label ",0
err_info_txt DB " - Retire e introduzca el disco antes de usarlo.",13,10,255
DB " - Extract and reinsert the disk before using it.",13,10,0
if1_txt DB " ficheros permitidos en el raíz.",13,10,255
DB " file capacity of root directory.",13,10,0
if2_txt DB " unidades de asignación.",13,10,255
DB " total clusters on disk.",13,10,0
if3_txt DB " bytes por unidad de asignación.",13,10,255
DB " bytes per cluster.",13,10,0
if4_txt DB " bytes totales en el disco.",13,10,255
DB " total bytes on disk.",13,10,0
if5_txt DB " bytes en sectores defectuosos.",13,10,255
DB " bytes in bad tracks.",13,10,0
if6_txt DB " bytes disponibles en el disco.",13,10,255
DB " bytes available on disk.",13,10,0
; ------------ Mensajes para el test.
test_txt1 DB 13,10,10,"2MGUI 1.0: TEST DE CAPACIDAD Y CALIDAD DE LA UNIDAD (ESC Salir)",13,10,255
DB 13,10,10,"2MGUI 1.0: DISKETTE DRIVE MAXIMUM CAPACITY AND QUALITY TEST (ESC Aborts)",13,10,0
test_txt_t DB " - Introduzca un disco que PERDERA TODOS LOS DATOS y pulse una tecla.",255
DB " - Insert a disk which will LOSE ALL DATA and press any key.",0
test_dma_txt DB " NOTA: El test puede producir resultados absurdos si su sistema o la",13,10
DB " configuración del mismo no soporta el acceso en modo NO-DMA.",13,10,255
DB " NOTE: This test may return nonsense results if your hardware or your",13,10
DB " system configuration does not support Non-DMA diskette access mode.",13,10,0
test_bdma_txt DB " NOTA: El buffer de DMA de su PC es demasiado pequeño; cambie la configuración",13,10
DB " del controlador de memoria si se cuelga o si aparece alguna excepción. Con",13,10
DB " QEMM basta añadir DMA=14 (1.44M) ó DMA=28 (2.88M) [algo más de lo normal].",13,10,255
DB " NOTA: The maximum DMA buffer on your PC is too small; if the PC hangs during",13,10
DB " the test or the EMM reports a exception, set a bigger buffer. With QEMM you",13,10
DB " can add a DMA=14 (1.44M) or a DMA=28 (2.88M) [a little more than normal].",13,10,0
test_txt2 DB 13," Probando ",255
DB 13," Testing ",0
test_txt3 DB " bytes en ",255
DB " bytes in ",0
test_txt4 DB ": [Disco de ",255
DB ": [",0
test_txt5 DB "] ",8,8,8,8,8,8,255
DB " diskette] ",8,8,8,8,8,8,0
test_r_txt11c DB 13," - Con ",255
DB 13," - With ",0
test_r_txt11s DB 13," - Sin ",255
DB 13," - Without ",0
test_r_txt12 DB "DMA y bits ",255
DB "DMA and ",0
test_r_txt12i DB "idénticos",255
DB "identic bits",0
test_r_txt12d DB "aleatorios",255
DB "random bits",0
test_r_txt13 DB " máxima capacidad por pista:",9,255
DB " maximum size in each track:",9,0
test_r_txt14 DB " bytes.",13,10,0
test_r_txt15 DB " Mínimo posible GAP anti-FIFO detectado:",9,9,9,255
DB " Possible minimum anti-FIFO GAP detected:",9,9,9,0
aviso_gap_txt DB " AVISO:",13,10
DB " - Su controladora precisa un GAP anti-FIFO mayor del establecido por defecto",13,10
DB " por el programa; indíquelo explícitamente con la opción /G al instalarlo.",13,10,255
DB " IMPORTANT:",13,10
DB " - Your diskette controller needs a bigger anti-FIFO GAP than default settings",13,10
DB " for program; set it with /G switch during program installation.",13,10,0
test_res_txt3 DB " NOTAS SOBRE LOS PARAMETROS /B Y /G:",13,10
DB " - El valor máximo soportado por /B para lograr más capacidad en los disquetes",13,10
DB " será normalmente la capacidad máxima en la pista MENOS el GAP anti-FIFO (20",13,10
DB " bytes por defecto). Es decir, reste 20 bytes de la capacidad de la pista",13,10
DB " para obtener el valor máximo de /B. Ajustando también dicho GAP con /G se",13,10
DB " puede obtener aún más capacidad. Cuidado: /G varía ligeramente con EMM386.",13,10
DB " - Use siempre los datos del test de PEOR resultado de todos los realizados.",13,10
DB " - Recuerde que estos disquetes serán *estropeados* al ser ESCRITOS por otras",13,10
DB " unidades que admitan menos capacidad, aunque podrán LEERSE sin problemas.",13,10
DB " - No utilice los valores límites si quiere que el programa funcione.",13,10,255
DB " NOTES ABOUT /B AND /G SWITCHES:",13,10
DB " - The maximum value supported by /B switch to get more disk capacity, will be",13,10
DB " usually the maximum size per track but SUBSTRACTING anti-FIFO GAP (20 bytes",13,10
DB " by default). This means that you have to substract 20 bytes to the maximum",13,10
DB " track size to obtain /B value. Adjusting also this GAP with /G switch, it's",13,10
DB " also possible to get more capacity. Warning: /G vary slightly with EMM386.",13,10
DB " - You must use always the results of WORST test of all performed.",13,10
DB " - Remember that this diskettes will be *damaged* when WRITTING them on other",13,10
DB " drives with less capacity, although they can be READED without problems.",13,10
DB " - Choosing minimum/maximum limits for values, the program may not work.",13,10,0
disco_def_txt DB " - Nota: ¡Este disco quizá tenga defectuosa la pista 0!.",13,10,255
DB " - Note: your diskette is perhaps damaged on track 0!",13,10,0
test_res_mal DB " - Su unidad de disco es pésima y no admite siquiera la capacidad mínima",13,10
DB " que necesita el programa. Cómprese otra mejor y, mientras tanto, no",13,10
DB " escriba sobre los discos 2MGUI que le pasen otras personas.",13,10,255
DB " - Your diskette drive is very bad and doesn't support the minimum size",13,10
DB " needed by this program. You must buy a better drive and, meanwhile, do",13,10
DB " not write on 2MGUI disks that other people send to you (only read!).",13,10,0 ;;;
spin0_txt DB " TEST DE VELOCIDAD DE ROTACION:",13,10,255
DB " ROTATION SPEED TEST:",13,10,0
spin1_txt DB 13," - Período de rotación: ",255
DB 13," - Rotation period: ",0
spin2_txt DB " ms (",0
spin3_txt DB ") [ESC-Fin]",255,") [ESC-End]",0
spind_txt DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,"; con una desviación de ",255
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,"; with a shift of ",0
spinf1_txt DB " ms",13,10," sobre al valor esperado de ",255
DB " ms from the",13,10," expected value of ",0
spinf2_txt DB " ms (unidad de ",255
DB " ms (",0
spinf3_txt DB " calidad).",13,10,255
DB " quality drive).",13,10,0
spinf_calidad DW 100
DW c_altisima
DW 250
DW c_alta
DW 500
DW c_mediana
DW 750
DW c_mala
DW 1000
DW c_pesima
DW 0
DW c_pesima
c_altisima DB "muy elevada",255,"very high",0
c_alta DB "alta",255,"high",0
c_mediana DB "mediana",255,"medium",0
c_mala DB "baja",255,"bad",0
c_pesima DB "pésima",255,"very bad",0
spine_txt DB 13," Nota: ha habido algún problema calculando el período de rotación.",13,10,255
DB 13," Note: it have been some problem computing rotation period.",13,10,0
test_esc_txt DB 13," - TEST interrumpido por el usuario.",13,10,255
DB 13," - TEST aborted by user.",13,10,0
disco_mal_txt DB " RECUERDE QUE EL DISCO DE PRUEBA ESTA INSERVIBLE: DEBERA FORMATEARLO.",13,10,255
DB " REMEMBER THAT TEST DISK IS NOW DAMAGED: YOU MUST FORMAT IT BEFORE USE.",13,10,0
; ------------ Ayuda.
ayuda_txt LABEL BYTE
DB 13,10,10
DB " 2M GUINNESS 1.0 - ACCESO DIRECTO A DISCO SIN CONTROLADORA",13,10
DB " (C) 1994-1995 Ciriaco García de Celis - Grupo Universitario de Informática",13,10
DB " C/Renedo, 2, 4-C; 47005 Valladolid (España) - ciri@gui.uva.es - 2:341/21.8",13,10
DB 10
DB " 2MGUI [U:] [/DD] [/DH] [/ED] [/T:n] [/R:n] [/C:n] [/S:n] [/F:n] [/N] [/K]",13,10
DB 10
DB " Este programa obtiene *toda* la capacidad de los discos antes de formatear;",13,10
DB " pudiendo incluso adaptarse a la velocidad de la unidad para obtener aún más.",13,10
DB 10
DB " Instálelo primero en el CONFIG.SYS con una línea como «DEVICE=2MGUI.EXE»;",13,10
DB " a raíz de ello se crearán tantas nuevas letras como unidades de alta densidad",13,10
DB " haya en el sistema. Los discos formateados por este programa sólo podrán ser",13,10
DB " accedidos en esas nuevas unidades, que también soportan discos estándar (y 2M",13,10
DB " si 2M está instalado). Es más, este programa permite utilizar discos 2M bajo",13,10
DB " OS/2 en esas nuevas unidades. Al conmutar entre dichas unidades y las físicas",13,10
DB " se simula un cambio de disco automático (y no se pide nuevo disco).",13,10
DB 10
DB " Para formatear los nuevos discos, ejecute 2MGUI indicando la unidad que les",13,10
DB " soporta. Por defecto se utiliza alta densidad; /DD selecciona doble densidad,",13,10
DB " /DH formatea 1/3 en alta densidad y 2/3 en doble (sólo discos de 360K) y /ED",13,10
DB " selecciona 2.88M; /T indica el nº de pistas (80-86, por defecto 82), /R el",13,10
DB " nº mínimo de ficheros en el raíz (1-240); /C el tamaño de cluster (128-16384)",13,10
DB " y /S el de sector (128-512), ambos han de ser potencia de 2; /F el nº de FATs",13,10
DB " (1-2); /N no verifica y /K evita las pausas.",13,10
DB " (1/5) [PULSA UNA TECLA]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " ┌───────────┬───────────┬────────────┐",13,10
DB " │ Doble │ Alta │ Extraalta │",13,10
DB " ┌───────────────────────────────┼───────────┼───────────┼────────────┼──────┐",13,10
DB " │ Récord absoluto previo a 2M │ 820.0 Kb │ 1394.0 Kb │ -- │ │",13,10
DB " │ Capacidad máxima 2M (2MF /M) │ 902.0 Kb │ 1558.0 Kb │ -- │ 5.25 │",13,10
DB " │ Capacidad mínima de 2MGUI │ 976.6 Kb │ 1639.8 Kb │ 1203.1 Kb# │ (5¼) │",13,10
DB " │ Capacidad límite física (82p) │ 1001.0 Kb │ 1668.2 Kb │ 1228.8 Kb# │ │",13,10
DB " ├───────────────────────────────┼───────────┼───────────┼────────────┼──────┤",13,10
DB " │ Récord absoluto previo a 2M │ 984.0 Kb │ 1722.0 Kb │ 2880.0 Kb │ │",13,10
DB " │ Capacidad máxima 2M (2MF /M) │ 1066.0 Kb │ 1886.0 Kb │ 3772.0 Kb* │ 3.5 │",13,10
DB " │ Capacidad mínima de 2MGUI │ 1176.0 Kb │ 1972.0 Kb │ 3944.0 Kb* │ (3½) │",13,10
DB " │ Capacidad límite física (82p) │ 1201.2 Kb │ 2002.0 Kb │ 4003.9 Kb │ │",13,10
DB " └───────────────────────────────┴───────────┴───────────┴────────────┴──────┘",13,10
DB " (#) Discos de 360K con formato /DH. (*) No probado. En la lista aparecen",13,10
DB " SOLO los formatos soportados por casi todas las unidades y ordenadores.",13,10
DB 10
DB " Los disquetes 2MGUI utilizan una tecnología totalmente nueva, que permite",13,10
DB " acceder directamente a la unidad, con una técnica ideada por Jesús Arias, sin",13,10
DB " emplear -en la práctica- la controladora de disquetes. En escritura son más",13,10
DB " lentos que un disco normal, pero leyendo lo superan. El consumo de memoria de",13,10
DB " este programa (17 Kb en 1.44M) es elevado. Estos discos son casi tan seguros",13,10
DB " como los 2M normales o los 2MF/M, pero su arquitectura no es la mejor de cara",13,10
DB " a su empleo bajo sistemas multitarea. Funcionan en la mayoría de PC, XT y AT",13,10
DB " con controladora y unidades de alta densidad.",13,10
DB " (2/5) [PULSA UNA TECLA]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " ────────────────── OTRAS OPCIONES DEL PROGRAMA SON ───────────────────",13,10
DB " /Q Hace un formateo rápido de las dos primeras pistas; útil para cambiar",13,10
DB " las características lógicas de un disco no defectuoso ya formateado.",13,10
DB " /L=et Establece la etiqueta de volúmen del disco (máximo 11 caracteres). Se",13,10
DB " admiten mayúsculas y minúsculas.",13,10
DB " /V=et Establece una etiqueta de volúmen incremental en series de discos (es",13,10
DB " preciso que acabe en número).",13,10
DB " /TEST Obtiene con exactitud total la capacidad admitida por la unidad que se",13,10
DB " indique, y determina la velocidad de rotación de la misma. El disco no",13,10
DB " necesita estar formateado y los datos que contuviera se pierden (test",13,10
DB " destructivo). Puede acompañarse de /DD ó /ED para elegir densidad; por",13,10
DB " defecto se realiza el test en alta densidad. También se admite /NODMA.",13,10
DB " /B=n Fuerza el formateo con una determinada capacidad por pista (quizá la",13,10
DB " obtenida por la prueba anterior). Así, se aprovechará totalmente la",13,10
DB " capacidad de una unidad concreta. Estos disquetes podrán ser LEIDOS en",13,10
DB " otras disqueteras, pero su ESCRITURA en unidades peores los dañará.",13,10
DB " /G=n Selecciona el valor del GAP anti-FIFO. La capacidad bruta de la pista",13,10
DB " es la suma de este valor (por defecto, 20) más el indicado con /B: un",13,10
DB " menor GAP permite aumentar /B pero disminuye la seguridad.",13,10
DB " /M=n Elige el número de pistas de alta densidad en el formato /DH (28 por",13,10
DB " defecto, equivalentes a la primera tercera parte del disco).",13,10
DB " /DRON Activa el soporte para DISKCOPY inverso (lo contrario es /DROFF). Use",13,10
DB " solo /DRON o /DROFF si DISKCOPY recalibrara en cada pista. /DRON está",13,10
DB " activo por defecto en DR-DOS 6 y Novell DOS 7.",13,10
DB " (3/5) [PULSA UNA TECLA]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " /DWOFF Desactiva la caché de escritura retardada (lo contrario es /DWON). Por",13,10
DB " defecto, la escritura retardada está activa. Inhíbala si detecta algún",13,10
DB " conflicto con otro software de sistema, si bien sería muy raro. Copiar",13,10
DB " discos (DISKCOPY) sin escritura retardada puede representar horas.",13,10
DB " /X=n Valor para desplazar el comienzo físico de una pista respecto a la que",13,10
DB " le precede, al conmutar de cabezal, expresado en grados (0-359°) de",13,10
DB " longitud angular de la pista (sector sliding /X), por defecto 55°.",13,10
DB " /Y=n Similar al anterior pero al conmutar de cilindro, por defecto 90°. No",13,10
DB " altere /X ni /Y si no conoce su significado: incide en el rendimiento.",13,10
DB " /NODMA Desactiva el funcionamiento en modo DMA. En modo DMA, QEMM necesita el",13,10
DB " parámetro DMA=13 (1.44M) ó DMA=25 (2.88M), aunque EMM386 no. Se puede",13,10
DB " evitar esto (o el cruce de una frontera de DMA) indicando esta opción:",13,10
DB " 2MGUI permite operar en los AT sin DMA, aunque así es menos compatible",13,10
DB " con ciertas configuraciones (cuando funciona, la seguridad es total).",13,10
DB " /EMS Sólo admitido junto a /NODMA, utiliza EMS para consumir sólo 5 Kb.",13,10
DB 10
DB " Derechos de copia:",13,10
DB " ──────────────────",13,10
DB " La tecnología empleada por 2MGUI y el formato de disco resultante son dominio",13,10
DB " público. Cualquier patente posterior de la técnica de acceso a pistas físicas",13,10
DB " completas, realizada en cualquier país, carecerá de validez. Este programa,",13,10
DB " sin embargo, sí es Copyright (C) de su autor. Puede ser libre y gratuitamente",13,10
DB " distribuído; la condición de registro es la del paquete 2M (enviar la tarjeta",13,10
DB " postal al autor).",13,10
DB " (4/5) [PULSA UNA TECLA]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " Ultimas consideraciones:",13,10
DB " ────────────────────────",13,10
DB " - Se puede ejecutar DISKCOPY sobre una unidad 2MGUI, sobre cualquier tipo de",13,10
DB " disco, siempre que el disco destino esté ya formateado, y tenga exactamente",13,10
DB " las mismas características físicas y tamaño que el origen. El DISKCOPY del",13,10
DB " MS-DOS (no del DR-DOS) falla en la primera ejecución sobre un nuevo disco",13,10
DB " cuando no es del mismo tipo que el accedido por última vez; esto es porque",13,10
DB " no soporta que un controlador de dispositivo modifique, dinámicamente, sus",13,10
DB " características físicas. Si DISKCOPY da error, vuelva a ejecutarlo; en todo",13,10
DB " caso, es mejor hacer antes un DIR sobre la unidad, para evitar problemas.",13,10
DB 10
DB " - 2MGUI realiza una escritura retardada (sólo en discos 2MGUI). El usuario no",13,10
DB " debería retirar el disco, aunque haya aparecido ya el prompt del sistema,",13,10
DB " hasta que haya transcurrido algo más de medio segundo.",13,10
DB 10
DB " Importante:",13,10
DB " ───────────",13,10
DB " - Bajo Windows 3 las operaciones sobre disquetes 2MGUI en el administrador de",13,10
DB " archivos dejan colapsado el sistema. Sin embargo, aunque el puntero del",13,10
DB " ratón no obedezca y el teclado parezca estar bloqueado, el sistema no está",13,10
DB " necesariamente colgado. Espere unos segundos antes de resetear. Windows 95",13,10
DB " es compatible con 2MGUI sólo en las sesiones de auténtico MS-DOS.",13,10
DB " - Es conveniente indicar BUFFERS=40 en CONFIG.SYS para mayor rendimiento.",13,10
DB 255
DB 13,10,10
DB " 2M GUINNESS 1.0 - DIRECT DISK DRIVE ACCESS BYPASSING CONTROLLER",13,10
DB " (C) 1994-1995 Ciriaco García de Celis - Grupo Universitario de Informática.",13,10
DB " C/Renedo, 2, 4-C; 47005 Valladolid (Spain) - ciri@gui.uva.es - 2:341/21.8",13,10
DB 10
DB " 2MGUI [U:] [/DD] [/DH] [/ED] [/T:n] [/R:n] [/C:n] [/S:n] [/F:n] [/N] [/K]",13,10
DB 10
DB " This program gets *all* disk's size available before format process; it is",13,10
DB " also capable of fitting itself at disk drive speed in order to get more size.",13,10
DB 10
DB " You must load it first in CONFIG.SYS with a line like «DEVICE=2MGUI.EXE»;",13,10
DB " from this moment, there will appear as many new disk drive letters as high",13,10
DB " density drives installed on the system. New disks formatted by this program",13,10
DB " only can be used on such new drives, which also support standard disks (and",13,10
DB " even 2M disks if 2M is loaded). In fact, 2MGUI lets OS/2 support 2M disks in",13,10
DB " these new drives. When changing from a new drive to the physical one or vice",13,10
DB " versa, a disk change is simulated (user won't be asked for new disk).",13,10
DB 10
DB " To format new disks, you can execute 2MGUI useing the drive which supports",13,10
DB " them. By default, high density is used; /DD selects double density, /DH makes",13,10
DB " 1/3 in high density and 2/3 in double density (only 360K disks) and /ED means",13,10
DB " 2.88M format; /T selects the number of tracks (80-86, 82 by default), /R the",13,10
DB " minimum number of root files (1-240); /C the cluster size (128-16384) and /S",13,10
DB " the sector size (128-512), both must be a power of 2; /F the FATs (1-2), /N",13,10
DB " turns verify off and /K skips keyboard pauses.",13,10
DB " (1/5) [PRESS ANY KEY]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " ┌───────────┬───────────┬────────────┐",13,10
DB " │ Double │ High │ Extra high │",13,10
DB " ┌───────────────────────────────┼───────────┼───────────┼────────────┼──────┐",13,10
DB " │ Absolute record before 2M │ 820.0 Kb │ 1394.0 Kb │ -- │ │",13,10
DB " │ Maximum 2M capacity (2MF /M) │ 902.0 Kb │ 1558.0 Kb │ -- │ 5.25 │",13,10
DB " │ Minimum 2MGUI capacity │ 976.7 Kb │ 1639.8 Kb │ 1203.1 Kb# │ (5¼) │",13,10
DB " │ Physical limit (82 tracks) │ 1001.0 Kb │ 1668.2 Kb │ 1228.8 Kb# │ │",13,10
DB " ├───────────────────────────────┼───────────┼───────────┼────────────┼──────┤",13,10
DB " │ Absolute record before 2M │ 984.0 Kb │ 1722.0 Kb │ 2880.0 Kb │ │",13,10
DB " │ Maximum 2M capacity (2MF /M) │ 1066.0 Kb │ 1886.0 Kb │ 3772.0 Kb* │ 3.5 │",13,10
DB " │ Minimum 2MGUI capacity │ 1176.0 Kb │ 1972.0 Kb │ 3944.0 Kb* │ (3½) │",13,10
DB " │ Physical limit (82 tracks) │ 1201.2 Kb │ 2002.0 Kb │ 4003.9 Kb │ │",13,10
DB " └───────────────────────────────┴───────────┴───────────┴────────────┴──────┘",13,10
DB " (#) 360K diskettes with /DH format. (*) Not tested. Here are listed ONLY",13,10
DB " those disk formats supported by most diskette drives and computer systems.",13,10
DB 10
DB " 2MGUI disks use a completely new technology to access a diskette drive",13,10
DB " directly, with a technique discovered by Jesús Arias, bypasing in fact the",13,10
DB " diskette drive controller. Writing is a little slower than a normal disk but",13,10
DB " reading is faster. The memory spent by 2MGUI (usually, 17Kb in 1.44M) is a",13,10
DB " little high. These disks are almost as reliable as 2M normal disks or 2MF/M",13,10
DB " ones, but their design is not as suitable for use in real multitasking",13,10
DB " environs. These diskette formats work on most PC, XT or AT computers with",13,10
DB " high density drives and disk controllers.",13,10
DB " (2/5) [PRESS ANY KEY]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " ──────────────────── OTHER SWITCHES SUPPORTED ARE ────────────────────",13,10
DB " /Q Performs a quick format of two first tracks. Useful to change logical",13,10
DB " characteristics of a full non-defective already 2mgui-formatted disk.",13,10
DB " /L=lb Sets the volume label of the disk (maximum of 11 characters). It will",13,10
DB " be accepted in either uppercase and lowercase.",13,10
DB " /V=lb Sets an automatic sequencing of labels (the specified one must be",13,10
DB " number terminated).",13,10
DB " /TEST Evals, with high accuracy, the disk capacity supported by the selected",13,10
DB " disk drive, and also measures the drive rotation speed. The test disk",13,10
DB " doesn't need to be formatted and data stored will be lost (destructive",13,10
DB " test). It can be used with /DD or /ED switches to select disk density;",13,10
DB " by default, high density will be used. Also /NODMA can be selected.",13,10
DB " /B=n Forzes a new track size (perhaps the maximum track size reported by",13,10
DB " the previous disk test). So, you can employ all disk capacity of your",13,10
DB " own drive. These disks can be READ without problem on any other disk",13,10
DB " drives, but WRITING them in poorer drives will damage data stored.",13,10
DB " /G=n Selects the anti-FIFO gap value. The crude track size is the addition",13,10
DB " of this value (by default, 20) and the size set with /B: a smaller GAP",13,10
DB " lets you to increment /B but decreases disk reliability.",13,10
DB " /M=n Sets the number of high density tracks in /DH format (by default, 28;",13,10
DB " which means the first third part of the disk).",13,10
DB " /DRON Turns on inverse DISKCOPY support (the opposite is /DROFF). Only must",13,10
DB " be used /DRON or /DROFF if DISKCOPY recalibrates on each track. /DRON",13,10
DB " is set by default in DR-DOS 6 and Novell DOS 7.",13,10
DB " (3/5) [PRESS ANY KEY]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " /DWOFF Disables delayed-write cache (the opposite is /DWON). By default, the",13,10
DB " delayed write is active. You can turn it off if you detect a conflict",13,10
DB " with any other system software, but this is really unusual. To copy",13,10
DB " disks (DISKCOPY) without delayed write may take hours.",13,10
DB " /X=n Value to shift the beginning of a track from the previous one, when",13,10
DB " changing the head selected shown in degrees (0-359°) of angular length",13,10
DB " of the track (sector sliding /X), 55° by default.",13,10
DB " /Y=n Similar to previous switch, but when changing the cylinder (90°). Do",13,10
DB " not modify /X or /Y without knowing how: they alter disk performance.",13,10
DB " /NODMA Turns off DMA mode. In DMA mode, QEMM needs a DMA=13 (1.44M) or DMA=25",13,10
DB " (2.88M) switch, but EMM386 does not need it. You can avoid this (or a",13,10
DB " DMA frontier crossing problem) with this option: 2MGUI can work in AT",13,10
DB " systems without using DMA; but in this way, it is less compatible with",13,10
DB " some system configurations (but if works, the reliability is similar).",13,10
DB " /EMS Only allowed with /NODMA, saves memory (uses 5 Kb) using EMS instead.",13,10
DB 10
DB " Copyright:",13,10
DB " ──────────",13,10
DB " The technology used by 2MGUI and the resulting disk format are, both, public",13,10
DB " domain. Any patent registered in any country with the technique of access to",13,10
DB " complete tracks will be void. This program, however, is Copyright (C) of its",13,10
DB " author. It can be freely and without charge distributed; the condition to be",13,10
DB " a registered user is the same that with 2M package (to send a postcard to the",13,10
DB " author).",13,10
DB " (4/5) [PRESS ANY KEY]",1
DB 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8," ",13,10,10
DB " Some finally notes:",13,10
DB " ───────────────────",13,10
DB " - It is possible to run DISKCOPY into a 2MGUI drive, over any one disk format",13,10
DB " available, but target diskette must be already formatted, and must be of",13,10
DB " the same physical characteristics and size as source one. MS-DOS DISKCOPY",13,10
DB " (not DR-DOS one) fails on first execution over a new disk, when it is not",13,10
DB " of the same type as the latest accessed the last time; the problem occurs",13,10
DB " because DISKCOPY doesn't support that a device drive modifies, on the fly,",13,10
DB " it physical characteristics. If DISKCOPY returns an error execute it again;",13,10
DB " but it's preferable to perform a DIR command over the drive before copying.",13,10
DB 10
DB " - 2MGUI performs a delayed-write on diskette drives (speeding up only 2MGUI",13,10
DB " diskettes). The user must not extract the disk although system prompt has",13,10
DB " already returned, until after at least a half second and a little more.",13,10
DB 10
DB " Important:",13,10
DB " ──────────",13,10
DB " - Under Windows 3, operations performed on 2MGUI disks under file manager may",13,10
DB " appear to hang the system. However, although mouse pointer does not answer",13,10
DB " and keyboard seems to be locked, the system has not necessarily crashed.",13,10
DB " Wait for some seconds before resetting it. Windows 95 is compatible with",13,10
DB " 2MGUI only in true MS-DOS sessions.",13,10
DB " - It is recommended to set BUFFERS=40 in CONFIG.SYS to improve performance.",13,10
DB 0
buffer_aux DB 256 DUP (0) ; buffer para alguna función del DOS/EMS
_PRINCIPAL ENDS
tampila EQU 2048 ; 2 Kb de pila son suficientes
_PILA SEGMENT STACK 'STACK'
DB tampila DUP (?)
_PILA ENDS
END main
